ucn 4.2.3 → 5.0.2

package/core/output/public.js

@@ -0,0 +1,462 @@
+'use strict';
+
+/**
+ * Public v5 presentation router.
+ *
+ * CLI and MCP both call this module after the shared execute() path.  The
+ * engine's narrower internal results remain independently testable, while the
+ * public surface has one formatter decision for each canonical command.
+ */
+
+const { COMMAND_CONTRACTS } = require('../command-contracts');
+const { COMMAND_TRUST_MATRIX } = require('../trust-matrix');
+const { toCliName, toMcpName, formatSurfaceMessage } = require('../registry');
+
+const legacy = {
+    ...require('./analysis'),
+    ...require('./analysis-ext'),
+    ...require('./brief'),
+    ...require('./check'),
+    ...require('./doctor'),
+    ...require('./endpoints'),
+    ...require('./extraction'),
+    ...require('./find'),
+    ...require('./graph'),
+    ...require('./refactoring'),
+    ...require('./reporting'),
+    ...require('./search'),
+    ...require('./tracing'),
+};
+
+function block(title, text) {
+    if (!text) return '';
+    return `${title}\n${'─'.repeat(Math.min(60, title.length || 1))}\n${text}`;
+}
+
+function appendNote(text, note) {
+    return note ? `${text}\n\n${note}` : text;
+}
+
+/** Canonicalize object keys so JSON bytes do not depend on index provenance. */
+function canonicalJsonValue(value) {
+    if (Array.isArray(value)) return value.map(canonicalJsonValue);
+    if (!value || typeof value !== 'object') return value;
+    const canonical = {};
+    for (const key of Object.keys(value).sort()) {
+        canonical[key] = canonicalJsonValue(value[key]);
+    }
+    return canonical;
+}
+
+function contractMeta(command) {
+    const contract = COMMAND_CONTRACTS[command];
+    const trust = COMMAND_TRUST_MATRIX[command];
+    if (!contract || !trust) return undefined;
+    return {
+        question: contract.question,
+        decisionSafety: trust.decisionSafety,
+        truth: contract.truth,
+        next: contract.next,
+    };
+}
+
+function modeOf(command, result) {
+    if (result && result._publicMode) return result._publicMode;
+    if (command === 'impact') return result && Array.isArray(result.functions) ? 'diff' : 'symbol';
+    if (command === 'trace') return result && result.direction === 'down' ? 'callees' : 'callers';
+    if (command === 'tests') return result && result.root ? 'affected' : 'direct';
+    if (command === 'check') return result && result.expectedArgs ? 'symbol' : 'diff';
+    return undefined;
+}
+
+function presentationHints(surface = 'cli') {
+    if (surface === 'mcp') {
+        return {
+            surface: 'mcp',
+            all: 'use all=true',
+            limit: 'Use limit=<n> to return and display more results.',
+            source: 'Run command=source with name=<handle> to inspect a listed symbol.',
+            usages: name => `run command=usages with name=${name}`,
+            detailed: 'Use detailed=true to list all functions and classes.',
+            top: 'Use top=<n> or all=true to show more.',
+            health: 'run command=repo with sections=health and deep=true for detail',
+            expandUnverified: 'expand_unverified=true',
+            includeMethods: 'Use include_methods=true to show them.',
+            nextRepo: result => [
+                ...(result.suggest ? [`command=show name=${result.suggest}`] : []),
+                'command=repo sections=files detailed=true',
+                'command=repo sections=stats hot=true top=20',
+                'command=repo sections=health deep=true',
+            ],
+        };
+    }
+    return {
+        surface: 'cli',
+        all: 'use --all',
+        limit: 'Use --limit=N to return and display more results.',
+        source: 'Use source <handle> to inspect a listed symbol.',
+        usages: name => `ucn usages ${name}`,
+        detailed: 'Use --detailed to list all functions and classes.',
+        top: 'Use --top=N or --all to show more.',
+        health: 'ucn repo --sections=health --deep for detail',
+        expandUnverified: '--expand-unverified',
+        includeMethods: 'Use --include-methods to show them.',
+        nextRepo: result => [
+            ...(result.suggest ? [`ucn show ${result.suggest}`] : []),
+            'ucn repo --sections=files --detailed',
+            'ucn repo --sections=stats --hot --top=20',
+            'ucn repo --sections=health --deep',
+        ],
+    };
+}
+
+function formatSource(result, hints = presentationHints()) {
+    const extractionHints = hints.surface === 'mcp'
+        ? {
+            maxLinesHint: 'use max_lines=<n>, or omit it for the full function',
+            classSourceHint: 'Use max_lines=<n> to see source, or run command=source with name=<method-handle> for an individual method.',
+        }
+        : {};
+    const mode = modeOf('source', result);
+    if (mode === 'lines' || (result && Array.isArray(result.lines))) {
+        return legacy.formatLines(result);
+    }
+    if (mode === 'class') return legacy.formatClassResult(result, extractionHints);
+    return legacy.formatFnResult(result, extractionHints);
+}
+
+function projectContextText(text, selected) {
+    if (!text) return text;
+    const keepCallers = selected.has('callers');
+    const keepCallees = selected.has('callees');
+    if (keepCallers && keepCallees) return text;
+    const lines = text.split('\n');
+    const projected = [];
+    let band = null;
+    const metadata = /^(?:NON-CALL OCCURRENCES|ACCOUNT|CONTRACT|WARNING|FILTERED|CALLEE ACCOUNT):/;
+    for (const line of lines) {
+        if (/^CALLERS —/.test(line)) band = 'callers';
+        else if (/^CALLEES(?: —| \()/.test(line)) band = 'callees';
+        else if (metadata.test(line)) band = null;
+        if ((band === 'callers' && !keepCallers) ||
+            (band === 'callees' && !keepCallees)) continue;
+        projected.push(line);
+    }
+    return projected.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd();
+}
+
+function formatShow(result, params = {}, hints = presentationHints()) {
+    const selected = new Set(result.sections || []);
+    const parts = [];
+
+    if (result.summary) parts.push(block('SUMMARY', legacy.formatBrief(result.summary)));
+    if (result.context) {
+        const context = { ...result.context };
+        const formatted = legacy.formatContext(context, {
+            showConfidence: params.showConfidence !== false,
+            compact: params.compact !== false,
+            expandHint: hints.source,
+            allHint: hints.all,
+            usagesHint: hints.usages(context.function || result.target),
+        });
+        parts.push(block('RELATIONSHIPS', projectContextText(formatted.text, selected)));
+    }
+    if (result.source) parts.push(block('SOURCE', formatSource(result.source, hints)));
+    if (result.dependencies) parts.push(block('DEPENDENCIES', legacy.formatSmart(result.dependencies)));
+    if (result.tests) {
+        parts.push(block('TESTS', formatTests(
+            result.tests,
+            { ...params, depth: 0 },
+            hints,
+        )));
+    }
+    if (result.types) {
+        const seen = new Set();
+        const types = (result.types.types || []).map(type => ({
+            ...type,
+            relativePath: type.relativePath || type.file,
+            startLine: type.startLine || type.line,
+        })).filter(type => {
+            const key = `${type.name}\0${type.type}\0${type.relativePath}\0${type.startLine}`;
+            if (seen.has(key)) return false;
+            seen.add(key);
+            return true;
+        });
+        parts.push(block('TYPES', legacy.formatTypedef(types, result.target)));
+    }
+    if (result.example) parts.push(block('EXAMPLE', legacy.formatExample(result.example, result.target)));
+    if (result.related) parts.push(block('RELATED', legacy.formatRelated(result.related, {
+        all: params.all,
+        top: params.top,
+        allHint: hints.all,
+    })));
+
+    return parts.join('\n\n');
+}
+
+function formatTrace(result, params = {}, hints = presentationHints()) {
+    const traceHints = {
+        allHint: hints.all,
+        expandUnverifiedHint: hints.expandUnverified,
+        includeMethodsHint: hints.includeMethods,
+    };
+    const mode = modeOf('trace', result);
+    if (mode === 'entrypoints') return legacy.formatReverseTrace(result, {
+        ...traceHints,
+        allHint: 'Increase depth for a wider path search.',
+    });
+    if (mode === 'callers') return legacy.formatBlast(result, {
+        ...traceHints,
+        allHint: hints.surface === 'mcp'
+            ? 'Use all=true to lift the per-node child cap; depth controls hops only.'
+            : 'Use --all to lift the per-node child cap; --depth controls hops only.',
+    });
+    return legacy.formatTrace(result, {
+        ...traceHints,
+        allHint: 'Increase depth for a wider callee tree.',
+    });
+}
+
+function formatImpact(result, params = {}) {
+    return modeOf('impact', result) === 'diff'
+        ? legacy.formatDiffImpact(result, { all: params.all })
+        : legacy.formatImpact(result, { compact: params.compact !== false });
+}
+
+function formatTests(result, params = {}, hints = presentationHints()) {
+    return modeOf('tests', result) === 'affected'
+        ? legacy.formatAffectedTests(result, { all: params.all, allHint: hints.all })
+        : legacy.formatTests(result, params.name);
+}
+
+function formatDeps(result, params = {}, hints = presentationHints()) {
+    if (modeOf('deps', result) === 'cycles' || result.cycles) {
+        return legacy.formatCircularDeps(result);
+    }
+    const parts = [legacy.formatGraph(result.graph, {
+        showAll: params.all || params.depth != null,
+        maxDepth: params.depth ?? 2,
+        file: result.file,
+        depthHint: hints.surface === 'mcp'
+            ? 'Use depth=<n> for a deeper graph.'
+            : 'Use --depth=N for a deeper graph.',
+        allHint: hints.all,
+    })];
+    if (result.imports) parts.push(block('IMPORT DECLARATIONS', legacy.formatImports(result.imports, result.file)));
+    if (result.importers) parts.push(block('IMPORTERS', legacy.formatExporters(result.importers, result.file)));
+    return parts.join('\n\n');
+}
+
+function formatRepo(result, params = {}, hints = presentationHints()) {
+    const parts = [];
+    if (result.summary) {
+        parts.push(legacy.formatOrient(result.summary, {
+            healthHint: hints.health,
+            nextHints: hints.nextRepo,
+        }));
+    }
+    if (result.files) {
+        parts.push(block('FILES', legacy.formatToc(result.files, {
+            detailedHint: hints.detailed,
+            topHint: hints.top,
+        })));
+    }
+    if (result.stats) parts.push(block('STATISTICS', legacy.formatStats(result.stats, {
+        top: params.top || 0,
+        topHint: hints.surface === 'mcp' ? 'use top=<n> to show more' : 'use --top=N to show more',
+    })));
+    if (result.health) {
+        parts.push(block('HEALTH', legacy.formatDoctor(result.health, {
+            deepHint: hints.surface === 'mcp' ? 'use deep=true' : 'use --deep',
+        })));
+    }
+    return parts.join('\n\n');
+}
+
+function formatPublicText(command, result, params = {}, execution = {}) {
+    const hints = presentationHints(execution.surface);
+    if (result?.scopeWarning?.hint) {
+        result.scopeWarning = {
+            ...result.scopeWarning,
+            hint: formatSurfaceMessage(result.scopeWarning.hint, execution.surface),
+        };
+    }
+    let text;
+    switch (command) {
+        case 'show': text = formatShow(result, params, hints); break;
+        case 'find':
+            text = modeOf('find', result) === 'type'
+                ? legacy.formatTypedef(result, params.name)
+                : legacy.formatFindDetailed(result, params.name, {
+                    compact: params.compact,
+                    withSource: params.withSource,
+                    top: params.limit,
+                    all: !!params.all,
+                    limitHint: hints.limit,
+                });
+            break;
+        case 'usages': text = legacy.formatUsages(result, params.name, {
+            compact: params.compact,
+            all: params.all,
+            allHint: hints.all,
+        }); break;
+        case 'search':
+            text = execution.structural || result?.meta?.mode === 'structural'
+                ? legacy.formatStructuralSearch(result, {
+                    topHint: hints.surface === 'mcp'
+                        ? 'Use top=<n> to see more.' : 'Use --top=N to see more.',
+                    unusedFlag: hints.surface === 'mcp' ? 'unused=true' : '--unused',
+                })
+                : legacy.formatSearch(result, params.term, {
+                    topHint: hints.surface === 'mcp'
+                        ? 'Use top=<n> to see more.' : 'Use --top=N to see more.',
+                    includeTestsHint: hints.surface === 'mcp'
+                        ? 'use include_tests=true to include'
+                        : 'use --include-tests to include',
+                });
+            break;
+        case 'source': text = formatSource(result, hints); break;
+        case 'trace': text = formatTrace(result, params, hints); break;
+        case 'impact': text = formatImpact(result, params); break;
+        case 'tests': text = formatTests(result, params, hints); break;
+        case 'deps': text = formatDeps(result, params, hints); break;
+        case 'api': text = legacy.formatApi(result, params.file || '.'); break;
+        case 'check':
+            text = modeOf('check', result) === 'symbol'
+                ? legacy.formatVerify(result)
+                : legacy.formatCheck(result);
+            break;
+        case 'plan': text = legacy.formatPlan(result, { surface: execution.surface }); break;
+        case 'repo': text = formatRepo(result, params, hints); break;
+        case 'deadcode': text = legacy.formatDeadcode(result, {
+            top: params.top || 0,
+            topHint: hints.top,
+            ...(hints.surface === 'mcp' && {
+                decoratedHint: `${result.excludedDecorated || 0} decorated/annotated symbol(s) hidden (framework-registered). Use include_decorated=true to include them.`,
+                exportedHint: `${result.excludedExported || 0} exported symbol(s) excluded from the audit (public API may have external callers). Use include_exported=true to audit them.`,
+                externalContractHint: `${result.excludedExternalContract || 0} symbol(s) hidden (override an out-of-tree base class — reachable via external contract, not dead). Use include_exported=true to include them.`,
+            }),
+        }); break;
+        case 'entrypoints': text = legacy.formatEntrypoints(result); break;
+        case 'endpoints': text = legacy.formatEndpoints(result, {
+            bridge: result._bridge,
+            unmatched: result._unmatched,
+            serverOnly: result._serverOnly,
+            clientOnly: result._clientOnly,
+        }); break;
+        case 'stacktrace': text = legacy.formatStackTrace(result); break;
+        case 'auditAsync': text = legacy.formatAuditAsync(result); break;
+        default: throw new Error(`No public formatter for command: ${command}`);
+    }
+    return appendNote(text, execution.note
+        ? formatSurfaceMessage(execution.note, execution.surface)
+        : execution.note);
+}
+
+function formatPublicJson(command, result, params = {}, execution = {}) {
+    let commandMeta = {};
+    let data = result;
+
+    // Ambiguous bare-name resolution is a surface-level trust decision. Keep
+    // it in the common envelope even for array results (notably `tests`, whose
+    // auxiliary metadata is intentionally non-enumerable).
+    if (result?.warnings?.length > 0) {
+        commandMeta.warnings = result.warnings;
+    }
+
+    // Keep the stable public envelope while reusing the endpoint serializer's
+    // trimmed records and aggregate metadata. This prevents private routing
+    // fields from leaking and preserves the established machine contract.
+    if (command === 'endpoints') {
+        const formatted = JSON.parse(legacy.formatEndpointsJson(result, {
+            bridge: result?._bridge,
+            unmatched: result?._unmatched,
+        }));
+        commandMeta = formatted.meta || {};
+        data = formatted.data;
+    }
+    if (command === 'deadcode' && Array.isArray(result)) {
+        commandMeta.deletionSafety = 'review-required';
+        commandMeta.excludedExported = result.excludedExported || 0;
+        commandMeta.excludedDecorated = result.excludedDecorated || 0;
+        commandMeta.excludedExternalContract = result.excludedExternalContract || 0;
+        commandMeta.excludedRuntimeContract = result.excludedRuntimeContract || 0;
+        commandMeta.pythonImplicitExportFiles = result.pythonImplicitExportFiles || 0;
+        commandMeta.excludedDynamicDispatch = result.excludedDynamicDispatch || 0;
+        commandMeta.computedDispatch = result.computedDispatch || { count: 0, names: [] };
+        if (result.coverage) commandMeta.coverage = result.coverage;
+        if (result.limitInfo) {
+            commandMeta.total = result.limitInfo.total;
+            commandMeta.truncated = true;
+        }
+    }
+    if (command === 'search' && result?.meta) {
+        commandMeta.searchMode = result.meta.mode;
+        commandMeta.totalMatches = result.meta.totalMatches;
+        commandMeta.shownMatches = result.meta.shownMatches;
+        commandMeta.truncatedMatches = result.meta.truncatedMatches;
+        commandMeta.limit = result.meta.limit;
+        if (result.meta.truncatedMatches > 0) commandMeta.truncated = true;
+        if (result.unsupportedMatches) commandMeta.unsupportedMatches = result.unsupportedMatches;
+    }
+    if (command === 'entrypoints' && result?.filterInfo) {
+        commandMeta.hiddenTestEntrypoints = result.filterInfo.hiddenTests;
+        commandMeta.testsIncluded = result.filterInfo.testsIncluded;
+        if (result.limitInfo) {
+            commandMeta.total = result.limitInfo.total;
+            commandMeta.truncated = true;
+        }
+    }
+    // Handles are the documented spine (`Pass the resulting handle to show/
+    // impact/source`) — the JSON records must carry them, not make agents
+    // concatenate relativePath:startLine:name themselves.
+    if (command === 'find' && Array.isArray(result)) {
+        const { formatSymbolHandle } = require('../shared');
+        if (result.findInfo) {
+            commandMeta.total = result.findInfo.total;
+            commandMeta.shown = result.findInfo.shown;
+            if (result.findInfo.shown < result.findInfo.total) commandMeta.truncated = true;
+        }
+        data = result.map(item => {
+            const handle = formatSymbolHandle(item);
+            return handle ? { handle, ...item } : item;
+        });
+    }
+    // Mixed-language disclosure for commands whose result is not
+    // account-shaped: the counts must be machine-readable, not note-only.
+    if ((command === 'find' || command === 'usages' || command === 'tests') &&
+        result?.unsupportedMatches) {
+        commandMeta.unsupportedMatches = result.unsupportedMatches;
+    }
+    if (command === 'usages' && result?.analysisGaps) {
+        commandMeta.analysisGaps = result.analysisGaps;
+    }
+
+    const surfaceCommand = execution.surface === 'mcp'
+        ? toMcpName(command)
+        : execution.surface === 'cli' ? toCliName(command) : command;
+
+    const envelope = {
+        meta: {
+            command: surfaceCommand,
+            ...(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
+            // successful empty result at the envelope level too.
+            ...(data && data.ok === false && { ok: false }),
+            ...(modeOf(command, result) && { mode: modeOf(command, result) }),
+            contract: contractMeta(command),
+            ...commandMeta,
+            ...(execution.note && { note: execution.note }),
+        },
+        data,
+    };
+    return JSON.stringify(canonicalJsonValue(envelope), null, 2);
+}
+
+module.exports = {
+    formatPublicText,
+    formatPublicJson,
+    contractMeta,
+    modeOf,
+};

package/core/output/refactoring.js

@@ -4,6 +4,7 @@
 
 const { unverifiedReasonLabel, advisoryLine } = require('./shared');
 const { formatAccountLines } = require('./analysis');
+const { formatSurfaceMessage } = require('../registry');
 
 /**
  * Render the v4 unverified band shared by verify and plan: capped one-liners
@@ -41,9 +42,10 @@ function formatPlan(plan, options = {}) {
         // Only show the parameter list when the error result carries one —
         // unrelated errors (multi-op rejection) don't, and "none" would be
         // wrong for functions that have parameters.
+        const nativeError = formatSurfaceMessage(plan.error, options.surface || 'cli');
         return plan.currentParams
-            ? `Error: ${plan.error}\nCurrent parameters: ${plan.currentParams.join(', ') || 'none'}`
-            : `Error: ${plan.error}`;
+            ? `Error: ${nativeError}\nCurrent parameters: ${plan.currentParams.join(', ') || 'none'}`
+            : `Error: ${nativeError}`;
     }
 
     const lines = [];
@@ -52,6 +54,9 @@ function formatPlan(plan, options = {}) {
     lines.push(`Refactoring plan: ${plan.operation}`);
     lines.push('═'.repeat(60));
     lines.push(`${plan.file}:${plan.startLine}`);
+    for (const warning of plan.warnings || []) {
+        lines.push(`Note: ${warning.message}`);
+    }
     lines.push('');
 
     // Before/After
@@ -63,6 +68,13 @@ function formatPlan(plan, options = {}) {
     // Summary
     lines.push(`CHANGES NEEDED: ${plan.totalChanges}`);
     lines.push(`  Files affected: ${plan.filesAffected}`);
+    if (plan.changeSummary) {
+        const summary = plan.changeSummary;
+        lines.push(`  Definition ${summary.definitions}, calls/references ${summary.calls}, imports ${summary.imports}, exports ${summary.exports}; manual review required for ${summary.reviewRequired} of these changes`);
+    }
+    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.`);
+    }
     if (plan.scopeWarning) {
         lines.push(`  Note: ${plan.scopeWarning.hint}`);
     }
@@ -79,9 +91,11 @@ function formatPlan(plan, options = {}) {
 
     lines.push('BY FILE:');
     for (const [file, changes] of byFile) {
-        lines.push(`\n${file} (${changes.length} changes)`);
+        lines.push(`\n${file} (${changes.length} change${changes.length === 1 ? '' : 's'})`);
         for (const change of changes) {
-            lines.push(`  :${change.line}`);
+            const kind = change.editKind ? ` [${change.editKind}]` : '';
+            const review = change.needsReview ? ' [review required]' : '';
+            lines.push(`  :${change.line}${kind}${review}`);
             lines.push(`    ${change.expression}`);
             lines.push(`    → ${change.suggestion}`);
         }
@@ -128,6 +142,7 @@ function formatPlanJson(plan) {
             complete: (plan.unverifiedCount || 0) === 0,
             unverified: plan.unverifiedCount || 0,
             ...(plan.account && { account: plan.account }),
+            ...(plan.warnings?.length > 0 && { warnings: plan.warnings }),
         },
         data: {
             found: true,
@@ -139,11 +154,19 @@ function formatPlanJson(plan) {
             after: { signature: plan.after.signature },
             totalChanges: plan.totalChanges,
             filesAffected: plan.filesAffected,
+            ...(plan.changeSummary && { changeSummary: plan.changeSummary }),
+            ...(plan.unchangedSites > 0 && { unchangedSites: plan.unchangedSites }),
             changes: plan.changes.map(c => ({
                 file: c.file,
                 line: c.line,
                 expression: c.expression,
-                suggestion: c.suggestion
+                suggestion: c.suggestion,
+                ...(c.newExpression && { newExpression: c.newExpression }),
+                ...(c.editKind && { editKind: c.editKind }),
+                ...(c.isDefinition && { isDefinition: true }),
+                ...(c.isImport && { isImport: true }),
+                ...(c.isExport && { isExport: true }),
+                ...(c.needsReview && { needsReview: true }),
             })),
             // v4 tiered contract passthrough
             unverifiedCount: plan.unverifiedCount,
@@ -187,6 +210,9 @@ function formatVerify(result, options = {}) {
     lines.push('═'.repeat(60));
     lines.push(`${result.file}:${result.startLine}`);
     lines.push(result.signature);
+    for (const warning of result.warnings || []) {
+        lines.push(`Note: ${warning.message}`);
+    }
     lines.push('');
 
     // Expected args (max null = unbounded rest param)
@@ -196,16 +222,21 @@ function formatVerify(result, options = {}) {
     lines.push('');
 
     // Summary
-    // BUG M1: don't claim "All calls valid" when 0 valid + N uncertain.
-    // Status precedence: mismatches > 0 → fail; total === 0 → empty;
-    // valid === 0 && uncertain > 0 → all-uncertain; valid > 0 && mismatches === 0 → ok.
+    // A partial check is never a clean pass. Agents often consume the headline
+    // and omit the counters, so any uncertain site must remain visible there.
     let status;
     if (result.mismatches > 0) {
-        status = `✗ ${result.mismatches} mismatch${result.mismatches === 1 ? '' : 'es'}`;
+        status = `✗ ${result.mismatches} mismatch${result.mismatches === 1 ? '' : 'es'}` +
+            (result.uncertain > 0 ? `; ${result.uncertain} uncertain` : '');
     } else if (result.totalCalls === 0) {
         status = 'ℹ No calls found';
     } else if (result.valid === 0 && result.uncertain > 0) {
         status = '⚠ All calls uncertain (no resolved sites)';
+    } else if (result.uncertain > 0) {
+        status = `⚠ Partial verification: ${result.valid} valid, ${result.uncertain} uncertain`;
+    } else if (result.unverifiedCount > 0) {
+        status = `⚠ ${result.valid} confirmed call${result.valid === 1 ? '' : 's'} valid; ` +
+            `${result.unverifiedCount} unverified site${result.unverifiedCount === 1 ? '' : 's'} not arg-checked`;
     } else {
         status = '✓ All calls valid';
     }
@@ -291,6 +322,7 @@ function formatVerifyJson(result) {
             uncertain: result.uncertain,
             unverified: result.unverifiedCount || 0,
             ...(result.account && { account: result.account }),
+            ...(result.warnings?.length > 0 && { warnings: result.warnings }),
         },
         data: {
             found: true,
@@ -343,7 +375,7 @@ function formatStackTrace(result) {
     const stAdvisory = advisoryLine(result.advisory);
     if (stAdvisory) lines.push(stAdvisory);
     if (result.skippedFrames > 0) {
-        lines.push(`(${result.skippedFrames} frame(s) without file:line — Unknown Source, native — skipped)`);
+        lines.push(`(${result.skippedFrames} runtime frame(s) outside the indexed project or without a resolvable project file — skipped)`);
     }
 
     for (let i = 0; i < result.frames.length; i++) {