ucn 5.3.8 → 5.4.1

package/core/ast-analysis.js

@@ -28,6 +28,101 @@ const CALLABLE_NODES = new Set([
     'operator_declaration', 'conversion_operator_declaration',
 ]);
 
+const DECLARATION_NODES = {
+    class: new Set(['class_declaration', 'abstract_class_declaration', 'class_definition', 'class_specifier', 'class']),
+    struct: new Set(['struct_item', 'struct_specifier', 'struct_declaration', 'type_spec']),
+    interface: new Set(['interface_declaration', 'type_spec']),
+    type: new Set(['type_alias_declaration', 'type_definition', 'type_spec', 'type_alias', 'type_item', 'associated_type']),
+    enum: new Set(['enum_declaration', 'enum_item', 'enum_specifier']),
+    trait: new Set(['trait_item']),
+    impl: new Set(['impl_item']),
+    record: new Set(['record_declaration']),
+    field: new Set(['field_definition', 'public_field_definition', 'property_signature', 'field_declaration', 'variable_declarator']),
+    state: new Set(['variable_declarator', 'assignment', 'init_declarator', 'const_item', 'static_item', 'const_spec', 'var_spec']),
+};
+const FUNCTION_EXPRESSIONS = new Set([
+    'function_expression', 'generator_function', 'arrow_function', 'lambda',
+    'func_literal', 'closure_expression', 'lambda_expression', 'anonymous_method_expression',
+]);
+const COMMENT_NODES = new Set(['comment', 'line_comment', 'block_comment']);
+
+/**
+ * Compare declarations by AST tokens, not lines: a class header and its first
+ * method can share a line. Concrete methods belong to the callable diff;
+ * bodyless signatures, fields (including unindexed Python assignments), and
+ * nested types belong to the declaration. Function-valued fields retain their
+ * signature but not their executable body. Nothing here is persisted in the
+ * index, so old and current source use the same projection without a cache bump.
+ * Missing AST mappings return no snapshot; callers keep conservative reporting.
+ */
+function declarationSnapshots(content, language, symbols) {
+    const snapshots = new Map();
+    if (content == null || symbols.length === 0) return snapshots;
+    const parser = getParser(language);
+    if (!parser) return snapshots;
+    const root = safeParse(parser, content).rootNode;
+    const wantedKinds = new Set(symbols.flatMap(s => [...(DECLARATION_NODES[s.type] || [])]));
+    const candidates = new Map();
+    walkNamed(root, node => {
+        if (!wantedKinds.has(node.type)) return;
+        if (!candidates.has(node.type)) candidates.set(node.type, []);
+        candidates.get(node.type).push(node);
+    });
+    const hasName = (node, name) => {
+        if (!node) return false;
+        if (node.text === name) return true;
+        return hasName(node.childForFieldName('name') || node.childForFieldName('declarator') ||
+            (node.type === 'generic_type' && node.childForFieldName('type')), name);
+    };
+    for (const symbol of symbols) {
+        const kinds = DECLARATION_NODES[symbol.type];
+        if (!kinds) continue;
+        let declaration = null;
+        for (const kind of kinds) {
+            for (const node of candidates.get(kind) || []) {
+                if (node.startPosition.row + 1 < symbol.startLine ||
+                    node.endPosition.row + 1 > (symbol.endLine || symbol.startLine)) continue;
+                const name = node.childForFieldName('name') || node.childForFieldName('declarator') ||
+                    node.childForFieldName('left') || (symbol.type === 'impl' && node.childForFieldName('type'));
+                if (!hasName(name, symbol.typeName || symbol.name)) continue;
+                if (!declaration || node.endIndex - node.startIndex > declaration.endIndex - declaration.startIndex) {
+                    declaration = node;
+                }
+            }
+        }
+        if (!declaration || declaration.hasError) continue;
+        // Export modifiers and Python decorators live outside the declaration.
+        while (['export_statement', 'decorated_definition'].includes(declaration.parent?.type) &&
+            declaration.parent.startPosition.row + 1 >= symbol.startLine) declaration = declaration.parent;
+        const tokens = [];
+        const lines = new Set();
+        const visit = node => {
+            if (COMMENT_NODES.has(node.type) || node.type === 'pass_statement') return;
+            if (node.type === 'decorated_definition' &&
+                CALLABLE_NODES.has(node.childForFieldName('definition')?.type)) return;
+            // Class docstrings are documentation, not fields or inheritance.
+            if (language === 'python' && node.type === 'expression_statement' &&
+                node.namedChildCount === 1 && ['string', 'concatenated_string'].includes(node.namedChild(0).type)) return;
+            const body = CALLABLE_NODES.has(node.type) ? node.childForFieldName('body') : null;
+            if (body && !FUNCTION_EXPRESSIONS.has(node.type)) return;
+            if (node.childCount === 0) {
+                // Empty anonymous semicolons between members are separators.
+                if (node.type === ';' && ['class_body', 'interface_body', 'declaration_list'].includes(node.parent?.type)) return;
+                tokens.push([node.type, node.text]);
+                for (let line = node.startPosition.row + 1; line <= node.endPosition.row + 1; line++) lines.add(line);
+                return;
+            }
+            for (const child of node.children) {
+                if (body && child.id === body.id) continue;
+                visit(child);
+            }
+        };
+        visit(declaration);
+        snapshots.set(symbol, { signature: JSON.stringify(tokens), lines });
+    }
+    return snapshots;
+}
+
 const BRANCH_NODES = new Set([
     'if_statement', 'if_expression', 'elif_clause',
     'for_statement', 'for_in_statement', 'for_expression',
@@ -375,6 +470,7 @@ function projectComputedDispatch(index) {
 }
 
 module.exports = {
+    declarationSnapshots,
     computeAstComplexity,
     computedDispatchSites,
     projectComputedDispatch,

package/core/bridge.js

@@ -26,7 +26,7 @@
 'use strict';
 
 const fs = require('fs');
-const { codeUnitCompare } = require('./shared');
+const { codeUnitCompare, isTestPath } = require('./shared');
 const path = require('path');
 const { getCachedCalls } = require('./callers');
 const { getParser, safeParse } = require('../languages');
@@ -1490,9 +1490,12 @@ function endpoints(index, options = {}) {
         showUncertain: options.showUncertain !== false,
     };
 
-    let routes = opts.clientOnly ? [] : extractServerRoutes(index);
-    let requests = (opts.serverOnly ? [] : extractClientRequests(index));
-    let uncertainRequests = opts.serverOnly ? [] : (index._endpointsCache?.uncertainRequests || []);
+    const label = r => ({ ...r, isTest: isTestPath(r.file) });
+    const inScope = r => index.matchesFilters(r.file, { in: options.in }) &&
+        !(options.excludeTests && r.isTest);
+    let routes = (opts.clientOnly ? [] : extractServerRoutes(index)).map(label).filter(inScope);
+    let requests = (opts.serverOnly ? [] : extractClientRequests(index)).map(label).filter(inScope);
+    let uncertainRequests = (opts.serverOnly ? [] : (index._endpointsCache?.uncertainRequests || [])).map(label).filter(inScope);
     if (uncertainRequests.length > 0) {
         // A server route registration (`@app.get("/x")`, `router.get("/x", h)`)
         // is request-shaped too; the route inventory already owns those lines.
@@ -1514,12 +1517,14 @@ function endpoints(index, options = {}) {
         uncertainRequests = uncertainRequests.filter(r => r.method.toUpperCase() === opts.method || r.method === 'request');
     }
 
-    let bridges = opts.bridge ? bridgeEndpoints(index) : [];
+    let bridges = opts.bridge ? bridgeEndpoints(index).map(b => ({
+        ...b, route: label(b.route), request: label(b.request),
+    })) : [];
     if (!opts.showUncertain) {
         bridges = bridges.filter(b => b.matchType !== 'uncertain');
     }
     // If user filtered routes/requests, also constrain bridges
-    if (opts.method || opts.prefix) {
+    if (opts.method || opts.prefix || options.in || options.excludeTests) {
         const routeKeys = new Set(routes.map(r => `${r.absoluteFile}:${r.line}:${r.method}:${r.path}`));
         const reqKeys = new Set(requests.map(r => `${r.absoluteFile}:${r.line}:${r.method}:${r.path}`));
         bridges = bridges.filter(b =>

package/core/cache.js

@@ -713,7 +713,8 @@ function clearAllCaches() {
 // v225 (fix #357): Rust `use path::name as local` bindings record the original name with a paired `renames` alias.
 // v226: bundled/minified filename exclusions are disclosed in discoveryIssues.
 // v227: signature parameter/return text excludes AST comments in every language.
-const CACHE_FORMAT_VERSION = 227;
+// v228: Python keyword arguments retain the same callable-reference facts as positional arguments.
+const CACHE_FORMAT_VERSION = 228;
 const USAGE_CACHE_FILE = 'usage-results.json';
 
 /**

package/core/callers.js

@@ -291,6 +291,22 @@ function _javaConstructorDisposition(index, filePath, fileEntry, call, targetDef
     return 'unknown';
 }
 
+// A structural member passed as a value is not invocation syntax. Keep it
+// in the callback model only when a project member can actually be callable;
+// an unrelated standalone function's spelling is not such evidence. Module
+// members remain eligible because modules can export standalone functions.
+function isDataMemberReference(fileEntry, call, definitions) {
+    if (!call.isFunctionReference || !call.isMethod || call.receiverIsModule ||
+        call.receiverModuleSpecifier || langTraits(fileEntry?.language)?.typeSystem !== 'structural') return false;
+    if (_structuralModuleBindings(fileEntry, call).length > 0) return false;
+    return !definitions.some(def => !NON_CALLABLE_TYPES.has(def.type) &&
+        // A typed Python descriptor read really invokes its getter; retain
+        // that existing proof path. An untyped property spelling belongs to
+        // the separate property-access inventory, never the call band.
+        (!require('./accessors').isAccessorDefinition(def) || call.receiverType) &&
+        (def.className || def.receiver));
+}
+
 /**
  * Find all call sites that invoke the named symbol.
  *
@@ -697,6 +713,7 @@ function findCallers(index, name, options = {}) {
                 langTraits(fileEntry.language)?.typeSystem === 'structural';
 
             for (let call of calls) {
+                if (isDataMemberReference(fileEntry, call, options.targetDefinitions || definitions)) continue;
                 // fix #353: C# `Beta.Helper.Widget()` — the parser records a
                 // field hop rooted at `this` (Beta is no local). When the
                 // prefix names a project NAMESPACE that declares the last
@@ -5444,7 +5461,8 @@ function findCallees(index, definition, options = {}) {
         // to this definition's source range. Nested closures deliberately
         // remain in the slice and retain the existing inner-symbol rules.
         const calls = _callsInDefinitionRange(index, def.file, allCalls,
-            def.startLine, def.endLine);
+            def.startLine, def.endLine).filter(call => !isDataMemberReference(
+                index.files.get(def.file), call, index.symbols.get(call.name) || []));
         // The reachability walk uses the legacy (non-accounting) path and most
         // entry/test symbols contain no calls. Avoid constructing receiver,
         // overload, and flow machinery for an empty source range. Contract
@@ -5545,7 +5563,8 @@ function findCallees(index, definition, options = {}) {
             if (!entry) {
                 const defs = index.symbols.get(call.name) || [];
                 const owners = defs.filter(s => !NON_CALLABLE_TYPES.has(s.type)).length;
-                entry = { name: call.name, reason, callCount: 0, sites: [], ownerCount: owners, ...meta };
+                entry = { name: call.name, reason, callCount: 0, sites: [], ownerCount: owners,
+                    ...(call.isFunctionReference && { functionReference: true }), ...meta };
                 unverifiedCallees.set(key, entry);
             }
             entry.callCount++;

package/core/check.js

@@ -73,6 +73,11 @@ function check(index, options = {}) {
     const modified = (dr && Array.isArray(dr.functions)) ? dr.functions : [];
     const added    = (dr && Array.isArray(dr.newFunctions)) ? dr.newFunctions : [];
     const deleted  = (dr && Array.isArray(dr.deletedFunctions)) ? dr.deletedFunctions : [];
+    const declarations = [
+        ...(dr?.symbols || []).map(s => ({ ...s, _kind: 'modified', _nonCallable: true })),
+        ...(dr?.newSymbols || []).map(s => ({ ...s, _kind: 'added', _nonCallable: true })),
+        ...(dr?.deletedSymbols || []).map(s => ({ ...s, _kind: 'deleted', _nonCallable: true })),
+    ];
     const pathCounts = {
         changedPaths: dr?.changedPaths || 0,
         nonSourcePaths: dr?.nonSourcePaths || 0,
@@ -82,9 +87,10 @@ function check(index, options = {}) {
     const allChanged = [
         ...modified.map(f => ({ ...f, _kind: 'modified' })),
         ...added.map(f => ({ ...f, _kind: 'added' })),
+        ...declarations,
     ];
 
-    if (!dr || (modified.length === 0 && added.length === 0 && deleted.length === 0)) {
+    if (!dr || (allChanged.length === 0 && deleted.length === 0)) {
         // fix #283: say what the diff actually contained. "no changes
         // detected" with three changed files reads as a false negative in a
         // pre-commit hook — the truth is the changes are outside what the
@@ -95,7 +101,7 @@ function check(index, options = {}) {
         if (changedPaths > 0 && nonSourcePaths === changedPaths) {
             reason = `${changedPaths} changed path(s), all outside supported source files; untracked source files are included`;
         } else if (changedPaths > 0) {
-            reason = 'no callable-symbol changes in the diff or untracked source files';
+            reason = 'no indexed-symbol changes in the diff or untracked source files';
         }
         return {
             base: options.base || 'HEAD',
@@ -116,9 +122,23 @@ function check(index, options = {}) {
     // For each changed function, run verify and gather caller summary
     for (const fn of changed) {
         const filePath = fn.relativePath || fn.file || '';
+        if (fn._nonCallable) {
+            const dependency = fn.impact?.typeReferences || fn.impact?.propertyAccesses;
+            items.push({
+                name: fn.name, file: filePath, line: fn.startLine, kind: fn._kind,
+                symbolType: fn.type, requiresToolchainValidation: true,
+                callerCount: fn.impact?.totalCallSites || 0,
+                unverifiedCallerCount: fn.impact?.unverifiedSites?.length || 0,
+                dependencyCount: dependency?.confirmedCount || 0,
+                unverifiedDependencyCount: (dependency?.unverifiedCount || 0) + (fn.remainingReferences?.length || 0),
+                signatureMismatches: 0,
+                account: summarizeAccount(fn.impact?.account),
+            });
+            continue;
+        }
         let verifyResult;
         try {
-            verifyResult = index.verify(fn.name, { file: filePath });
+            verifyResult = index.verify(fn.name, { file: filePath, line: fn.startLine });
         } catch (e) {
             verifyResult = null;
         }
@@ -225,6 +245,13 @@ function check(index, options = {}) {
     // Action items
     const actions = [];
     for (const it of items) {
+        if (it.requiresToolchainValidation) {
+            actions.push({
+                severity: it.kind === 'added' ? 'warn' : 'error',
+                kind: 'declaration_change',
+                message: `${it.name}: ${it.kind} ${it.symbolType}; shape/inheritance compatibility is not checked by arity analysis — review dependency sites and run the compiler/type checker and tests`,
+            });
+        }
         if (!it.account || !it.account.textComplete) {
             actions.push({
                 severity: 'error',
@@ -272,7 +299,7 @@ function check(index, options = {}) {
         actions.push({
             severity: 'error',
             kind: 'truncated_change_set',
-            message: `${allChanged.length - limit} changed function(s) were not checked; rerun without --limit`,
+            message: `${allChanged.length - limit} changed symbol(s) were not checked; rerun without --limit`,
         });
     }
     if (testFiles.length > 0) {
@@ -289,9 +316,10 @@ function check(index, options = {}) {
     const signatureMismatches = items.reduce((sum, it) => sum + (it.signatureMismatches || 0), 0);
     const filteredEdges = items.reduce((sum, it) => sum + (it.account ? it.account.filtered || 0 : 0), 0);
     const usageReviewSymbols = items.filter(it => it.account && it.account.requiresUsageReview).length;
+    const unvalidatedDeclarations = items.filter(it => it.requiresToolchainValidation && it.kind !== 'added').length;
     const reviewRequired = incompleteAccounts > 0 || unverifiedCallSites > 0 ||
         signatureMismatches > 0 || filteredEdges > 0 || usageReviewSymbols > 0 ||
-        actions.some(a => a.kind === 'orphan_new') ||
+        actions.some(a => a.kind === 'orphan_new' || a.kind === 'declaration_change') ||
         !!(limit && allChanged.length > limit);
 
     return {
@@ -308,7 +336,7 @@ function check(index, options = {}) {
         totalTests: testCount,
         actions,
         trust: {
-            status: incompleteAccounts > 0 || signatureMismatches > 0
+            status: incompleteAccounts > 0 || signatureMismatches > 0 || unvalidatedDeclarations > 0
                 ? 'BLOCKED'
                 : reviewRequired ? 'REVIEW_REQUIRED' : 'READY_FOR_TOOLCHAIN',
             accountsChecked: items.filter(it => it.account && it.account.available).length,
@@ -317,6 +345,7 @@ function check(index, options = {}) {
             signatureMismatches,
             filteredEdges,
             usageReviewSymbols,
+            unvalidatedDeclarations,
             semanticComplete: false,
             safeToDelete: false,
             requiresCompilerAndTests: true,

package/core/command-contracts.js

@@ -301,7 +301,7 @@ const COMMAND_CONTRACTS = Object.freeze({
             { name: 'bridge', when: '`bridge=true`.', answer: 'Exact/parameterized route-request matches plus unmatched sides.' },
             { name: 'unmatched', when: '`unmatched=true`.', answer: 'Only unmatched supported boundaries.' },
         ],
-        defaults: ['Framework-specific static extraction.', 'Interpolated-path uncertainty remains visible unless hidden explicitly.'],
+        defaults: ['Framework-specific static extraction.', 'Test routes/requests are labeled; excludeTests=true hides them and in scopes a directory.', 'Interpolated-path uncertainty remains visible unless hidden explicitly.'],
         truth: 'Findings are static matches for supported framework call/decorator shapes; bridge confidence is match quality, not runtime probability.',
         nonGoals: ['Network discovery.', 'Frameworks not represented by an endpoint adapter.'],
         invalidCombinations: ['`serverOnly` and `clientOnly` cannot both describe a useful result.'],

package/core/execute.js

@@ -1462,6 +1462,7 @@ const HANDLERS = {
                 unused: p.unused || false,
                 caseSensitive: p.caseSensitive || false,
                 exclude,
+                testExclude: p.includeTests ? undefined : ['test files'],
                 in: p.in,
                 file: p.file,
                 top: topVal || (p.lines ? undefined : 50),
@@ -1470,13 +1471,15 @@ const HANDLERS = {
             const unsupported = (!p.regex && (p.term || p.name))
                 ? require('./account').scanUnsupportedFiles(index, p.term || p.name)
                 : null;
-            let note;
+            let note = result.meta.filesSkipped > 0
+                ? `${result.meta.filesSkipped} test file(s) hidden by default (--include-tests).`
+                : undefined;
             if (unsupported?.lines > 0) {
                 Object.defineProperty(result, 'unsupportedMatches', {
                     value: unsupported,
                     enumerable: false, writable: true, configurable: true,
                 });
-                note = `${unsupported.lines} matching line(s) in ${unsupported.fileCount} unsupported-language file(s) were not structurally analyzed; verify with grep/ripgrep.`;
+                note = combineNotes([note, `${unsupported.lines} matching line(s) in ${unsupported.fileCount} unsupported-language file(s) were not structurally analyzed; verify with grep/ripgrep.`]);
             }
             return { ok: true, result, structural: true, note };
         }
@@ -1793,6 +1796,8 @@ const HANDLERS = {
             method: normMethod,
             prefix: p.prefix || null,
             showUncertain: !p.hideUncertain,
+            in: p.in,
+            excludeTests: !!p.excludeTests,
         });
         if (p.framework != null && String(p.framework).trim() !== '') {
             const framework = String(p.framework).trim().toLowerCase();
@@ -1856,6 +1861,7 @@ const HANDLERS = {
         // Recompute meta after filtering
         result.meta = {
             totalRoutes: result.routes.length,
+            testRoutes: result.routes.filter(r => r.isTest).length,
             totalRequests: result.requests.length,
             uncertainRequests: (result.uncertainRequests || []).length,
             totalBridges: result.bridges.length,
@@ -2283,7 +2289,7 @@ const HANDLERS = {
         const limit = num(p.limit, undefined);
         let note;
         if (limit && limit > 0 && result) {
-            const groups = ['functions', 'moduleLevelChanges', 'newFunctions', 'deletedFunctions'];
+            const groups = ['functions', 'symbols', 'newSymbols', 'deletedSymbols', 'moduleLevelChanges', 'newFunctions', 'deletedFunctions'];
             const total = groups.reduce((sum, key) => sum + (result[key]?.length || 0), 0);
             if (total > limit) {
                 let remaining = limit;
@@ -2506,6 +2512,18 @@ function execute(index, command, params = {}) {
             const validationError = validatePublicParams(command, params);
             if (validationError) return { ok: false, error: validationError };
         }
+        // Public JSON paths and pasted stack frames may be absolute. Resolve
+        // only indexed files, then use the same relative scope as our handles.
+        const relativeIndexedFile = file => {
+            if (!file || !path.isAbsolute(file)) return file;
+            const resolved = index.resolveFilePathForQuery(file);
+            return typeof resolved === 'string' ? index.files.get(resolved).relativePath : file;
+        };
+        if (params.file) params.file = relativeIndexedFile(params.file);
+        const absoluteHandle = params.name && parseSymbolHandle(params.name);
+        if (absoluteHandle && path.isAbsolute(absoluteHandle.file)) {
+            params.name = relativeIndexedFile(absoluteHandle.file) + params.name.slice(absoluteHandle.file.length);
+        }
         // Resolve name-less handles (e.g. `lib.js:42`) via index lookup before dispatch.
         // Handles WITH a name suffix are handled later by applyClassMethodSyntax.
         if (params && params.name && looksLikeHandle(params.name)) {
@@ -2520,6 +2538,7 @@ function execute(index, command, params = {}) {
             }
         }
         const response = handler(index, params);
+        response.projectRoot = index.root;
         const bundled = (index.discoveryIssues || []).filter(issue => issue.reason === 'bundled');
         if (bundled.length > 0) {
             const files = bundled.slice(0, 5).map(issue => issue.relativePath).join(', ');

package/core/output/analysis-ext.js

@@ -207,8 +207,14 @@ function formatDiffImpact(result, options = {}) {
     if (s.modifiedFunctions > 0) parts.push(`${s.modifiedFunctions} modified`);
     if (s.deletedFunctions > 0) parts.push(`${s.deletedFunctions} deleted`);
     if (s.newFunctions > 0) parts.push(`${s.newFunctions} new`);
+    if (s.modifiedSymbols || s.newSymbols || s.deletedSymbols) {
+        parts.push(`${s.modifiedSymbols || 0} modified, ${s.newSymbols || 0} new, ${s.deletedSymbols || 0} deleted non-callable declarations`);
+    }
     parts.push(`${s.totalCallSites || 0} call sites across ${s.affectedFiles || 0} files`);
     if (s.unverifiedCallSites > 0) parts.push(`${s.unverifiedCallSites} unverified`);
+    if (s.totalDependencySites || s.unverifiedDependencySites) {
+        parts.push(`${s.totalDependencySites || 0} confirmed + ${s.unverifiedDependencySites || 0} unverified non-call dependency sites across ${s.dependencyFiles || 0} files`);
+    }
     lines.push(parts.join(', '));
     // fix #283: changed paths outside supported source are invisible to the
     // symbol analysis — disclose instead of silently narrowing the diff.
@@ -229,10 +235,10 @@ function formatDiffImpact(result, options = {}) {
             lines.push(`  ${fn.relativePath}:${fn.startLine}`);
             lines.push(`  ${fn.signature}`);
             if (fn.addedLines.length > 0) {
-                lines.push(`  Lines added: ${formatLineRanges(fn.addedLines)}`);
+                lines.push(`  Added at lines: ${formatLineRanges(fn.addedLines)}`);
             }
             if (fn.deletedLines.length > 0) {
-                lines.push(`  Lines deleted: ${formatLineRanges(fn.deletedLines)}`);
+                lines.push(`  Deleted at old lines: ${formatLineRanges(fn.deletedLines)}`);
             }
 
             if (fn.callers.length > 0) {
@@ -302,6 +308,24 @@ function formatDiffImpact(result, options = {}) {
         }
     }
 
+    for (const [key, title] of [['symbols', 'MODIFIED'], ['newSymbols', 'NEW'], ['deletedSymbols', 'DELETED']]) {
+        if (!result[key]?.length) continue;
+        lines.push(`\n${title} DECLARATIONS:`);
+        for (const symbol of result[key]) {
+            lines.push(`  ${symbol.type} ${symbol.name} — ${symbol.relativePath}:${symbol.startLine}`);
+            if (symbol.impact) {
+                lines.push(require('./analysis').formatImpact(symbol.impact, { compact: true }));
+            } else {
+                const refs = symbol.remainingReferences || [];
+                lines.push(`  Remaining name references: ${refs.length} unverified (deleted target)`);
+                for (const site of refs.slice(0, MAX_CALLERS_PER_FN)) {
+                    lines.push(`    ${site.file}:${site.line}: ${site.expression}`);
+                }
+                if (refs.length > MAX_CALLERS_PER_FN) lines.push(`    (+${refs.length - MAX_CALLERS_PER_FN} more)`);
+            }
+        }
+    }
+
     // Module-level changes
     if (result.moduleLevelChanges.length > 0) {
         lines.push('\nMODULE-LEVEL CHANGES:');

package/core/output/analysis.js

@@ -205,7 +205,7 @@ function formatCalleeAccountLine(acct) {
 function unverifiedCalleeLines(entries, compact) {
     if (!entries || entries.length === 0) return [];
     const lines = [];
-    lines.push(`${compact ? '' : '\n'}CALLEES — UNVERIFIED (${entries.length}) — call syntax, receiver/binding unresolved:`);
+    lines.push(`${compact ? '' : '\n'}CALLEES — UNVERIFIED (${entries.length}) — call or callable-reference syntax, receiver/binding unresolved:`);
     for (const u of entries) {
         const owners = u.ownerCount > 1 ? ` (${u.ownerCount} owners)` : '';
         const sites = u.sites && u.sites.length > 0 ? ` L${u.sites.join(',L')}` : '';
@@ -461,7 +461,7 @@ function formatContext(ctx, options = {}) {
 
         const typeUnverified = ctx.unverifiedCallers || [];
         if (typeUnverified.length > 0) {
-            lines.push(`\nCALLERS — UNVERIFIED (${typeUnverified.length}) — call syntax, no binding/receiver evidence:`);
+            lines.push(`\nCALLERS — UNVERIFIED (${typeUnverified.length}) — call or callable-reference syntax, no binding/receiver evidence:`);
             formatAmbiguityCandidates(lines, ctx.ambiguityCandidates);
             const cap = 10;
             let shown = 0;
@@ -688,7 +688,7 @@ function formatContext(ctx, options = {}) {
     // Actionable ambiguity: call syntax without enough identity evidence.
     // Always visible and capped at 10 one-liners unless --all.
     if (actionableUnverified.length > 0) {
-        lines.push(`${compact ? '' : '\n'}CALLERS — UNVERIFIED (${actionableUnverified.length}) — call syntax, no binding/receiver evidence:`);
+        lines.push(`${compact ? '' : '\n'}CALLERS — UNVERIFIED (${actionableUnverified.length}) — call or callable-reference syntax, no binding/receiver evidence:`);
         formatAmbiguityCandidates(lines, ctx.ambiguityCandidates);
         const cap = (ctx.meta && ctx.meta.all) ? Infinity : 10;
         let shown = 0;
@@ -837,8 +837,10 @@ function formatImpact(impact, options = {}) {
     }
 
     // By file (confirmed tier)
-    if (!compact) lines.push('');
-    lines.push('BY FILE:');
+    if (impact.byFile.length > 0) {
+        if (!compact) lines.push('');
+        lines.push('BY FILE:');
+    }
 
     // Evidence aggregate over ALL sites (replaces per-edge confidence lines)
     const allSites = impact.byFile.flatMap(g => g.sites);
@@ -881,7 +883,7 @@ function formatImpact(impact, options = {}) {
             for (const site of group.sites) {
                 const caller = site.callerName ? ` [${site.callerName}]` : '';
                 const expr = site.expression ? `: ${site.expression.replace(/\s+/g, ' ').slice(0, 100)}` : '';
-                lines.push(`  ${group.file}:${site.line}${caller}${expr}`);
+                lines.push(`  ${group.file}:${site.line}${caller} [${site.accessKind || 'access'}${Number.isInteger(site.column) ? `, column ${site.column + 1}` : ''}]${expr}`);
             }
         }
         if (access.unverifiedSites.length > 0) {
@@ -889,7 +891,7 @@ function formatImpact(impact, options = {}) {
             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}${expr}`);
+                lines.push(`  ${site.file}:${site.line}${caller} [${site.accessKind || 'access'}${Number.isInteger(site.column) ? `, column ${site.column + 1}` : ''}]${expr}`);
             }
             if (access.unverifiedSites.length > 10) {
                 lines.push(`  (+${access.unverifiedSites.length - 10} more unverified)`);
@@ -927,7 +929,7 @@ function formatImpact(impact, options = {}) {
 
     // Unverified tier: visible, capped at 10 one-liners
     if (impactUnverified.length > 0) {
-        lines.push(`${compact ? '' : '\n'}UNVERIFIED CALL SITES (${impactUnverified.length}) — call syntax, no binding/receiver evidence:`);
+        lines.push(`${compact ? '' : '\n'}UNVERIFIED CALL SITES (${impactUnverified.length}) — call or callable-reference syntax, no binding/receiver evidence:`);
         const cap = 10;
         for (const site of impactUnverified.slice(0, cap)) {
             const caller = site.callerName ? ` [${site.callerName}]` : '';
@@ -1085,7 +1087,7 @@ function formatAbout(about, options = {}) {
     const aboutUnverified = about.callers.unverified;
     if (aboutUnverified && aboutUnverified.total > 0) {
         lines.push('');
-        lines.push(`CALLERS — UNVERIFIED (${aboutUnverified.total}) — call syntax, no binding/receiver evidence:`);
+        lines.push(`CALLERS — UNVERIFIED (${aboutUnverified.total}) — call or callable-reference syntax, no binding/receiver evidence:`);
         for (const u of aboutUnverified.top) {
             const caller = u.callerName ? ` [${u.callerName}]` : '';
             const reason = u.reason ? ` (${unverifiedReasonLabel(u)})` : '';

package/core/output/check.js

@@ -29,15 +29,17 @@ function formatCheck(result) {
         if (result.trust.signatureMismatches) trustDetails.push(`${result.trust.signatureMismatches} signature mismatch(es)`);
         if (result.trust.filteredEdges) trustDetails.push(`${result.trust.filteredEdges} filtered edge(s)`);
         if (result.trust.usageReviewSymbols) trustDetails.push(`${result.trust.usageReviewSymbols} symbol(s) need usages review`);
+        if (result.trust.unvalidatedDeclarations) trustDetails.push(`${result.trust.unvalidatedDeclarations} declaration change(s) need toolchain validation`);
         if (trustDetails.length > 0) lines.push(`  ${trustDetails.join(' · ')}`);
     }
 
     // Changed functions section
     const items = result.changed || [];
+    const noun = items.some(it => it.symbolType) ? 'symbol' : 'function';
     if (result.truncated) {
-        lines.push(`Changed: ${items.length} of ${result.totalChanged} functions`);
+        lines.push(`Changed: ${items.length} of ${result.totalChanged} ${noun}s`);
     } else {
-        lines.push(`Changed: ${items.length} function${items.length === 1 ? '' : 's'}`);
+        lines.push(`Changed: ${items.length} ${noun}${items.length === 1 ? '' : 's'}`);
     }
     if (items.length === 0) {
         lines.push('  (none — only non-function changes)');
@@ -47,6 +49,7 @@ function formatCheck(result) {
             if (it.kind && it.kind !== 'changed') tags.push(it.kind.toUpperCase());
             if (it.signatureMismatches > 0) tags.push(`SIG-DRIFT(${it.signatureMismatches})`);
             if (it.orphan) tags.push('ORPHAN');
+            if (it.symbolType) tags.push(it.symbolType);
             if (it.account && !it.account.textComplete) tags.push('ACCOUNT-INCOMPLETE');
             const tagStr = tags.length ? ' [' + tags.join(', ') + ']' : '';
             let callers = it.callerCount != null ? `${it.callerCount} caller${it.callerCount === 1 ? '' : 's'}` : '';
@@ -54,6 +57,7 @@ function formatCheck(result) {
                 callers += ` (+${it.unverifiedCallerCount} unverified)`;
             }
             lines.push(`  ${it.name} (${it.file}:${it.line})${tagStr}  ${callers}`);
+            if (it.symbolType) lines.push(`    Dependencies: ${it.dependencyCount || 0} confirmed, ${it.unverifiedDependencyCount || 0} unverified`);
             if (it.mismatches && it.mismatches.length > 0) {
                 for (const m of it.mismatches.slice(0, 3)) {
                     const where = m.file ? ` at ${m.file}:${m.line}` : '';