ucn 5.3.4 → 5.3.6

package/core/confidence.js

@@ -8,12 +8,15 @@
 
 'use strict';
 
+const { createProvenance, validateConfirmation } = require('./provenance');
+
 // Resolution types ordered from most to least confident
 const RESOLUTION = {
     EXACT_BINDING:    'exact-binding',
     SAME_CLASS:       'same-class',
     RECEIVER_HINT:    'receiver-hint',
     SCOPE_MATCH:      'scope-match',
+    SINGLE_OWNER:     'single-owner',
     POSSIBLE_DISPATCH: 'possible-dispatch',
     NAME_ONLY:        'name-only',
     METHOD_AMBIGUOUS: 'method-ambiguous',
@@ -27,6 +30,7 @@ const SCORES = {
     [RESOLUTION.SAME_CLASS]:       0.92,
     [RESOLUTION.RECEIVER_HINT]:    0.80,
     [RESOLUTION.SCOPE_MATCH]:      0.65,
+    [RESOLUTION.SINGLE_OWNER]:     0.35,
     [RESOLUTION.POSSIBLE_DISPATCH]: 0.50,
     [RESOLUTION.NAME_ONLY]:        0.40,
     [RESOLUTION.METHOD_AMBIGUOUS]: 0.35,
@@ -46,6 +50,7 @@ const RESOLUTION_TIER = {
     // scope-match is only assigned with import/receiver/callback evidence
     // (see scoreEdge below) — that satisfies the contract's evidence clause.
     [RESOLUTION.SCOPE_MATCH]:   TIER.CONFIRMED,
+    [RESOLUTION.SINGLE_OWNER]: TIER.UNVERIFIED,
     // Nominal dispatch tiering: a call that CAN reach the target through
     // virtual dispatch (interface/supertype-typed receiver) or whose untyped
     // receiver faces multiple same-name owners is evidence a call happens —
@@ -61,7 +66,7 @@ function tierForResolution(resolution) {
     return RESOLUTION_TIER[resolution] || TIER.UNVERIFIED;
 }
 
-function scored(resolution, reasons) {
+function scored(resolution, reasons, evidence) {
     const evidenceScore = SCORES[resolution];
     return {
         confidence: evidenceScore,
@@ -69,6 +74,7 @@ function scored(resolution, reasons) {
         scoreKind: 'ordinal-evidence-not-probability',
         resolution,
         evidence: reasons,
+        provenance: createProvenance(evidence || {}, resolution),
     };
 }
 
@@ -95,38 +101,44 @@ function scoreEdge(evidence) {
     // (without this, a known mismatch would score receiver-hint 0.80).
     if (evidence.typeMismatch) {
         reasons.push('receiver type mismatch');
-        return scored(RESOLUTION.UNCERTAIN, reasons);
+        return scored(RESOLUTION.UNCERTAIN, reasons, evidence);
     }
 
     // Nominal dispatch tiering (contract surface only — callers.js sets these
     // flags exclusively under collectAccount, so legacy paths never see them).
     if (evidence.possibleDispatch) {
         reasons.push('interface/supertype dispatch');
-        return scored(RESOLUTION.POSSIBLE_DISPATCH, reasons);
+        return scored(RESOLUTION.POSSIBLE_DISPATCH, reasons, evidence);
     }
     if (evidence.methodAmbiguous) {
         reasons.push('untyped receiver, multiple same-name definitions');
-        return scored(RESOLUTION.METHOD_AMBIGUOUS, reasons);
+        return scored(RESOLUTION.METHOD_AMBIGUOUS, reasons, evidence);
     }
 
     // Exact binding match (highest confidence)
     if (evidence.hasBindingId) {
         reasons.push('binding-id match');
         if (evidence.hasImportEvidence) reasons.push('import-verified');
-        return scored(RESOLUTION.EXACT_BINDING, reasons);
+        return scored(RESOLUTION.EXACT_BINDING, reasons, evidence);
     }
 
     // Same-class resolution (self/this/super/cls)
     if (evidence.resolvedBySameClass) {
         reasons.push('same-class method');
         if (evidence.hasInheritanceChain) reasons.push('via inheritance');
-        return scored(RESOLUTION.SAME_CLASS, reasons);
+        return scored(RESOLUTION.SAME_CLASS, reasons, evidence);
     }
 
     // Receiver hint narrowed to specific type
     if (evidence.resolvedByReceiverHint || evidence.hasReceiverType) {
         reasons.push(evidence.hasReceiverType ? 'parser receiver-type' : 'local type inference');
-        return scored(RESOLUTION.RECEIVER_HINT, reasons);
+        return scored(RESOLUTION.RECEIVER_HINT, reasons, evidence);
+    }
+
+    if (evidence.hasSingleOwnerEvidence && !evidence.typeQualifiedReceiver &&
+        !evidence.moduleOwnedPath) {
+        reasons.push('single project owner, receiver identity unresolved');
+        return scored(RESOLUTION.SINGLE_OWNER, reasons, evidence);
     }
 
     // Function reference (callback / passed-as-argument). Argument position is
@@ -137,31 +149,30 @@ function scoreEdge(evidence) {
         reasons.push('function reference');
         if (evidence.hasImportEvidence || evidence.hasSamePackageEvidence) {
             reasons.push(evidence.hasImportEvidence ? 'import-supported' : 'same package/module');
-            return scored(RESOLUTION.SCOPE_MATCH, reasons);
+            return scored(RESOLUTION.SCOPE_MATCH, reasons, evidence);
         }
         reasons.push('no import evidence');
-        return scored(RESOLUTION.NAME_ONLY, reasons);
+        return scored(RESOLUTION.NAME_ONLY, reasons, evidence);
     }
 
     // Scope/import-supported match
     if (evidence.hasImportEvidence || evidence.hasReceiverEvidence ||
-        evidence.hasSamePackageEvidence || evidence.hasSingleOwnerEvidence) {
+        evidence.hasSamePackageEvidence) {
         if (evidence.hasImportEvidence) reasons.push('import-supported');
         if (evidence.hasReceiverEvidence) reasons.push('receiver binding in scope');
         if (evidence.hasSamePackageEvidence) reasons.push('same package/module');
-        if (evidence.hasSingleOwnerEvidence) reasons.push('single project method owner');
-        return scored(RESOLUTION.SCOPE_MATCH, reasons);
+        return scored(RESOLUTION.SCOPE_MATCH, reasons, evidence);
     }
 
     // Uncertain
     if (evidence.isUncertain) {
         reasons.push('ambiguous resolution');
-        return scored(RESOLUTION.UNCERTAIN, reasons);
+        return scored(RESOLUTION.UNCERTAIN, reasons, evidence);
     }
 
     // Name-only match (no additional evidence)
     reasons.push('name match only');
-    return scored(RESOLUTION.NAME_ONLY, reasons);
+    return scored(RESOLUTION.NAME_ONLY, reasons, evidence);
 }
 
 /**
@@ -192,4 +203,5 @@ module.exports = {
     tierForResolution,
     scoreEdge,
     filterByConfidence,
+    validateConfirmation,
 };

package/core/imports.js

@@ -446,18 +446,32 @@ function rustModuleOwnFile(dir, fromFile) {
  * @param {string[]} segments - Path segments to resolve
  * @returns {string|null}
  */
+function rustPathHasExactCase(base, file) {
+    // Rust names remain case-sensitive on case-insensitive filesystems.
+    // Check directory entries, rather than realpath, so legitimate symlinked
+    // modules keep their declared spelling and remain resolvable.
+    let current = base;
+    try {
+        for (const part of path.relative(base, file).split(path.sep)) {
+            if (!fs.readdirSync(current).includes(part)) return false;
+            current = path.join(current, part);
+        }
+        return true;
+    } catch { return false; }
+}
+
 function resolveRustModulePath(dir, segments) {
     // Try progressively shorter paths (items at the end may be types, not modules)
     for (let len = segments.length; len >= 1; len--) {
         const modPath = path.join(dir, ...segments.slice(0, len));
         // Try <path>.rs
         const rsFile = modPath + '.rs';
-        if (fs.existsSync(rsFile) && fs.statSync(rsFile).isFile()) {
+        if (fs.existsSync(rsFile) && fs.statSync(rsFile).isFile() && rustPathHasExactCase(dir, rsFile)) {
             return rsFile;
         }
         // Try <path>/mod.rs
         const modFile = path.join(modPath, 'mod.rs');
-        if (fs.existsSync(modFile) && fs.statSync(modFile).isFile()) {
+        if (fs.existsSync(modFile) && fs.statSync(modFile).isFile() && rustPathHasExactCase(dir, modFile)) {
             return modFile;
         }
     }
@@ -600,11 +614,11 @@ function resolveRustImport(importPath, fromFile, projectRoot) {
     if (!importPath.includes('::')) {
         // For mod declarations: <dir>/<name>.rs or <dir>/<name>/mod.rs
         const rsFile = path.join(fromDir, importPath + '.rs');
-        if (fs.existsSync(rsFile) && fs.statSync(rsFile).isFile()) {
+        if (fs.existsSync(rsFile) && fs.statSync(rsFile).isFile() && rustPathHasExactCase(fromDir, rsFile)) {
             return rsFile;
         }
         const modFile = path.join(fromDir, importPath, 'mod.rs');
-        if (fs.existsSync(modFile) && fs.statSync(modFile).isFile()) {
+        if (fs.existsSync(modFile) && fs.statSync(modFile).isFile() && rustPathHasExactCase(fromDir, modFile)) {
             return modFile;
         }
     }

package/core/index-ir.js

@@ -12,9 +12,14 @@ function createImportBindings(imports) {
     return imports.flatMap(item => (item.names || [])
         .filter(name => name && name !== '*' && name !== '_' && name !== '.')
         .map(name => {
-            const rename = (item.renames || []).find(candidate => candidate.original === name);
+            // A rename may be recorded under its original name (Python
+            // `from m import a as b` lists 'a') or under its local alias
+            // (Rust `use m::a as b` lists 'b', fix #357); both yield the
+            // binding {name: original, alias: local}.
+            const rename = (item.renames || []).find(candidate =>
+                candidate.original === name || candidate.local === name);
             return {
-                name,
+                name: rename ? rename.original : name,
                 module: item.module,
                 ...(item.type && { kind: item.type }),
                 ...(item.line != null && { line: item.line }),
@@ -81,7 +86,7 @@ const OPTIONAL_SYMBOL_FIELDS = Object.freeze([
     'returnedFunctionResult', 'isFunctionVariable', 'paramTypes', 'isAsync',
     'isGenerator', 'generics', 'ownerGenerics', 'genericBounds', 'extends', 'implements', 'indent', 'isNested',
     'enclosingType', 'isMethod', 'receiver', 'memberType', 'fieldType',
-    'aliasOf', 'aliasMembers', 'derefTarget', 'decorators', 'decoratorsWithArgs',
+    'aliasOf', 'aliasMembers', 'aliasTypeText', 'aliasTypeParameters', 'aliasTypeDefaults', 'derefTarget', 'decorators', 'decoratorsWithArgs',
     'annotationsWithArgs', 'attributesWithArgs', 'nameLine', 'traitImpl',
     'traitName', 'isSignature', 'memberAssigned', 'assignedReceiver', 'bodyScopedName',
     'registryMember', 'registryContainer', 'namespace',

package/core/ir.js

@@ -63,7 +63,7 @@ function normalizeSymbol(symbol, family, language, kind, owner = null) {
         'docstring', 'returnedFunctionResult', 'isFunctionVariable', 'paramTypes',
         'isAsync', 'isGenerator', 'generics', 'ownerGenerics', 'genericBounds', 'extends', 'implements', 'indent',
         'isNested', 'enclosingType', 'isMethod', 'memberType', 'fieldType',
-        'aliasOf', 'aliasMembers', 'derefTarget', 'decorators', 'decoratorsWithArgs',
+        'aliasOf', 'aliasMembers', 'aliasTypeText', 'aliasTypeParameters', 'aliasTypeDefaults', 'derefTarget', 'decorators', 'decoratorsWithArgs',
         'annotationsWithArgs', 'attributesWithArgs', 'nameLine', 'traitImpl',
         'traitName', 'isSignature', 'memberAssigned', 'assignedReceiver', 'bodyScopedName',
         'registryMember', 'registryContainer', 'isConstructor',

package/core/output/analysis.js

@@ -5,6 +5,7 @@ const fs = require('fs');
 const path = require('path');
 const { langTraits } = require('../../languages');
 const { dynamicImportsNote, formatGitLine, unverifiedReasonLabel } = require('./shared');
+const { provenanceReplacer } = require('./provenance');
 
 /**
  * One short sentence (~80 chars) of a docstring, suitable for inline display
@@ -40,7 +41,7 @@ function reachabilityDisplay(items, hasEntrypoints, label) {
 }
 
 // Display order for resolution labels in evidence aggregates (most → least confident)
-const RESOLUTION_ORDER = ['exact-binding', 'same-class', 'receiver-hint', 'scope-match', 'name-only', 'uncertain'];
+const RESOLUTION_ORDER = ['exact-binding', 'same-class', 'receiver-hint', 'scope-match', 'single-owner', 'name-only', 'uncertain'];
 
 /**
  * One aggregate evidence line per tier section, replacing per-edge confidence
@@ -51,8 +52,9 @@ function formatEvidenceLine(items) {
     if (!items || items.length === 0) return null;
     const counts = new Map();
     for (const it of items) {
-        if (!it.resolution) continue;
-        counts.set(it.resolution, (counts.get(it.resolution) || 0) + 1);
+        const rule = it.provenance?.rule || it.resolution;
+        if (!rule) continue;
+        counts.set(rule, (counts.get(rule) || 0) + 1);
     }
     if (counts.size === 0) return null;
     if (counts.size === 1) {
@@ -266,6 +268,8 @@ function formatContextJson(context) {
                     ...(c.evidenceScore !== undefined && { evidenceScore: c.evidenceScore }),
                     ...(c.scoreKind && { scoreKind: c.scoreKind }),
                     ...(c.resolution && { resolution: c.resolution }),
+                    ...(c.provenance && { provenance: c.provenance }),
+                    ...(c.siteProvenance && { siteProvenance: c.siteProvenance }),
                     ...(c.tier && { tier: c.tier })
                 })),
                 unverifiedCallers: (context.unverifiedCallers || []).map(c => ({
@@ -281,6 +285,8 @@ function formatContextJson(context) {
                     ...(c.evidenceScore !== undefined && { evidenceScore: c.evidenceScore }),
                     ...(c.scoreKind && { scoreKind: c.scoreKind }),
                     ...(c.resolution && { resolution: c.resolution }),
+                    ...(c.provenance && { provenance: c.provenance }),
+                    ...(c.siteProvenance && { siteProvenance: c.siteProvenance }),
                     ...(c.reason && { reason: c.reason }),
                     ...(c.dispatchVia && { dispatchVia: c.dispatchVia }),
                     ...(c.dispatchCandidates != null && { dispatchCandidates: c.dispatchCandidates }),
@@ -295,7 +301,7 @@ function formatContextJson(context) {
                 }),
                 ...(context.warnings && { warnings: context.warnings })
             }
-        });
+        }, provenanceReplacer);
     }
 
     // Standard function/method context
@@ -321,6 +327,8 @@ function formatContextJson(context) {
                 ...(c.calledAs && { calledAs: c.calledAs }),
                 ...(c.isFunctionReference && { functionReference: true }),
                 ...(c.confidence != null && { confidence: c.confidence, resolution: c.resolution }),
+                ...(c.provenance && { provenance: c.provenance }),
+                ...(c.siteProvenance && { siteProvenance: c.siteProvenance }),
                 ...(c.evidenceScore != null && { evidenceScore: c.evidenceScore }),
                 ...(c.scoreKind && { scoreKind: c.scoreKind }),
                 ...(c.tier && { tier: c.tier }),
@@ -335,6 +343,8 @@ function formatContextJson(context) {
                 ...(c.calledAs && { calledAs: c.calledAs }),
                 ...(c.isFunctionReference && { functionReference: true }),
                 ...(c.confidence != null && { confidence: c.confidence, resolution: c.resolution }),
+                ...(c.provenance && { provenance: c.provenance }),
+                ...(c.siteProvenance && { siteProvenance: c.siteProvenance }),
                 ...(c.evidenceScore != null && { evidenceScore: c.evidenceScore }),
                 ...(c.scoreKind && { scoreKind: c.scoreKind }),
                 tier: 'unverified',
@@ -358,6 +368,8 @@ function formatContextJson(context) {
                 params: c.params,  // FULL params
                 weight: c.weight || 'normal',  // Dependency weight: core, setup, utility
                 ...(c.confidence != null && { confidence: c.confidence, resolution: c.resolution }),
+                ...(c.provenance && { provenance: c.provenance }),
+                ...(c.siteProvenance && { siteProvenance: c.siteProvenance }),
                 ...(c.evidenceScore != null && { evidenceScore: c.evidenceScore }),
                 ...(c.scoreKind && { scoreKind: c.scoreKind }),
                 ...(c.tier && { tier: c.tier }),
@@ -370,7 +382,7 @@ function formatContextJson(context) {
             unverifiedCallees: context.unverifiedCallees || [],
             ...(context.warnings && { warnings: context.warnings })
         }
-    });
+    }, provenanceReplacer);
 }
 
 /**
@@ -456,7 +468,7 @@ function formatContext(ctx, options = {}) {
             for (const u of typeUnverified) {
                 if (shown >= cap) break;
                 const callerName = u.callerName ? ` [${u.callerName}]` : '';
-                const reason = u.reason ? ` (${u.reason})` : '';
+                const reason = u.reason ? ` (${unverifiedReasonLabel(u)})` : '';
                 const expr = u.content ? `: ${u.content.trim().replace(/\s+/g, ' ').slice(0, 100)}` : '';
                 lines.push(`  [${itemNum}] ${u.relativePath}:${u.line}${callerName}${expr}${reason}`);
                 expandable.push({
@@ -943,7 +955,7 @@ function formatImpactJson(impact) {
     if (!impact) {
         return JSON.stringify({ found: false, error: 'Function not found' }, null, 2);
     }
-    return JSON.stringify(impact, null, 2);
+    return JSON.stringify(impact, provenanceReplacer, 2);
 }
 
 /** Format about command output - text. The "tell me everything" output for AI agents. */
@@ -1215,7 +1227,7 @@ function formatAboutJson(about) {
     if (!about) {
         return JSON.stringify({ found: false, error: 'Symbol not found' }, null, 2);
     }
-    return JSON.stringify(about, null, 2);
+    return JSON.stringify(about, provenanceReplacer, 2);
 }
 
 module.exports = {

package/core/output/provenance.js

@@ -0,0 +1,41 @@
+'use strict';
+
+// Full witnesses stay on engine results for validation and oracle reports.
+// Public answers carry the facts an agent needs to locate and interpret a site,
+// rather than repeating declaration/member inventories for every occurrence.
+function compactProvenance(provenance) {
+    if (!provenance) return provenance;
+    const facts = provenance.facts || {};
+    const origin = facts.receiverOrigin;
+    return {
+        rule: provenance.rule,
+        ...(provenance.rules?.length > 1 && { rules: provenance.rules }),
+        validation: provenance.validation,
+        ...(provenance.diagnostic && provenance.validation !== 'unsupported' &&
+            { diagnostic: provenance.diagnostic }),
+        ...(facts.receiverTypeSource && { receiverSource: facts.receiverTypeSource }),
+        ...(Number.isInteger(origin?.line) && { originLine: origin.line }),
+    };
+}
+
+function compactExclusions(excluded) {
+    if (!Array.isArray(excluded?.evidence)) return excluded;
+    const { evidence, ...summary } = excluded;
+    const groups = new Map();
+    for (const site of evidence) {
+        const p = site.provenance || {};
+        const row = { rule: p.rule || 'unattributed', validation: p.validation || 'unreported',
+            ...(p.diagnostic && p.validation !== 'unsupported' && { diagnostic: p.diagnostic }) };
+        const key = JSON.stringify(row);
+        if (!groups.has(key)) groups.set(key, { ...row, count: 0 });
+        groups.get(key).count++;
+    }
+    return { ...summary, evidenceSummary: [...groups.values()] };
+}
+
+function provenanceReplacer(key, value) {
+    if (key === 'provenance') return compactProvenance(value);
+    return key === 'excluded' ? compactExclusions(value) : value;
+}
+
+module.exports = { compactProvenance, compactExclusions, provenanceReplacer };

package/core/output/public.js

@@ -12,6 +12,7 @@ const { COMMAND_CONTRACTS } = require('../command-contracts');
 const { COMMAND_TRUST_MATRIX } = require('../trust-matrix');
 const { toCliName, toMcpName, formatSurfaceMessage } = require('../registry');
 const { LINES_COMMANDS, formatPublicLines, formatPublicRaw } = require('./lines');
+const { provenanceReplacer } = require('./provenance');
 
 const legacy = {
     ...require('./analysis'),
@@ -44,7 +45,7 @@ function canonicalJsonValue(value) {
     if (!value || typeof value !== 'object') return value;
     const canonical = {};
     for (const key of Object.keys(value).sort()) {
-        canonical[key] = canonicalJsonValue(value[key]);
+        canonical[key] = canonicalJsonValue(provenanceReplacer(key, value[key]));
     }
     return canonical;
 }

package/core/output/shared.js

@@ -342,6 +342,9 @@ function formatGitLine(git) {
  */
 function unverifiedReasonLabel(entry) {
     if (!entry || !entry.reason) return '';
+    if (entry.reason === 'provenance-incomplete' && entry.provenance?.diagnostic) {
+        return `${entry.reason}: ${entry.provenance.diagnostic}`;
+    }
     if (entry.reason === 'possible-dispatch' && entry.externalContract) {
         // External contract (fix #210): the candidate set is open — any
         // external subtype of the contract — so no implementation count.