ucn 5.3.4 → 5.3.6

package/languages/rust.js

@@ -5,6 +5,9 @@
  * modules, macros, and const/static declarations.
  */
 
+const { ReceiverTypeMap, typeOrigin } = require('./type-evidence');
+
+
 const {
     traverseTree,
     traverseTreeCached,
@@ -916,6 +919,14 @@ function _processClass(node, types, processedRanges, lines, code) {
                 members: [],
                 modifiers: visibility ? [visibility] : [],
                 ...(aliasOf && { aliasOf }),
+                aliasTypeText: node.childForFieldName('type')?.text,
+                aliasTypeParameters: (node.childForFieldName('type_parameters')?.namedChildren || [])
+                    .map(parameter => parameter.type === 'type_identifier' ? parameter.text
+                        : parameter.childForFieldName('name')?.text ||
+                            parameter.namedChildren.find(child => child.type === 'type_identifier')?.text)
+                    .map(name => name || null),
+                aliasTypeDefaults: (node.childForFieldName('type_parameters')?.namedChildren || [])
+                    .map(parameter => parameter.childForFieldName('default_type')?.text || null),
                 ...(docstring && { docstring })
             });
         }
@@ -1525,12 +1536,57 @@ function _tokenTreeCallArgsAfter(children, nameIndex) {
     return args?.type === 'token_tree' && args.text.startsWith('(') ? args : null;
 }
 
+// Extract the base type name from a Rust type node (strips &, &mut, Box<>, etc.)
+function extractTypeName(typeNode) {
+    if (!typeNode) return null;
+    if (typeNode.type === 'type_identifier' ||
+        typeNode.type === 'primitive_type') {
+        return typeNode.text;
+    }
+    if (typeNode.type === 'reference_type') {
+        // &Filter or &mut Filter -> Filter
+        for (let i = 0; i < typeNode.namedChildCount; i++) {
+            const r = extractTypeName(typeNode.namedChild(i));
+            if (r) return r;
+        }
+    }
+    if (typeNode.type === 'abstract_type' || typeNode.type === 'dynamic_type') {
+        for (let i = 0; i < typeNode.namedChildCount; i++) {
+            const r = extractTypeName(typeNode.namedChild(i));
+            if (r) return r;
+        }
+    }
+    if (typeNode.type === 'generic_type') {
+        // Box<Filter> -> Filter (or get the outer type)
+        return extractTypeName(typeNode.namedChild(0));
+    }
+    if (typeNode.type === 'scoped_type_identifier') {
+        // module::Type -> Type
+        const nameNode = typeNode.childForFieldName('name');
+        return nameNode?.text || null;
+    }
+    return null;
+}
+
+
+// Shared by ordinary AST calls and macro token-tree calls. Both carry the
+// same self-field owner identity; a field spelling is never a local receiver.
+function findEnclosingImplType(node) {
+    for (let parent = node.parent; parent; parent = parent.parent) {
+        if (parent.type === 'impl_item') {
+            const type = parent.childForFieldName('type');
+            return (type && extractTypeName(type)) || undefined;
+        }
+    }
+    return undefined;
+}
+
 function extractCallsFromTokenTree(tree, enclosingFunction, calls, getReceiverType,
     isPatternShadow, isFlowInvalidated, context = 'invocation') {
     const contextKind = typeof context === 'string' ? context : context.kind;
     const containerMacro = typeof context === 'object' ? context.containerMacro : undefined;
     const inheritedTokenTypes = typeof context === 'object' && context.tokenTypes
-        ? context.tokenTypes : new Map();
+        ? context.tokenTypes : new ReceiverTypeMap();
     const children = [];
     for (let i = 0; i < tree.childCount; i++) children.push(tree.child(i));
     // Macro arguments are token trees, so a typed closure parameter is not a
@@ -1544,7 +1600,7 @@ function extractCallsFromTokenTree(tree, enclosingFunction, calls, getReceiverTy
         let close = i + 1;
         while (close < children.length && children[close].type !== '|') close++;
         if (close >= children.length) break;
-        const bindings = new Map(inheritedTokenTypes);
+        const bindings = new ReceiverTypeMap(inheritedTokenTypes);
         let cursor = i + 1;
         while (cursor < close) {
             const nameNode = children[cursor];
@@ -1562,7 +1618,7 @@ function extractCallsFromTokenTree(tree, enclosingFunction, calls, getReceiverTy
             if (simplePath) {
                 const identifiers = typeTokens.filter(token => token.type === 'identifier');
                 if (identifiers.length > 0) {
-                    bindings.set(nameNode.text, identifiers[identifiers.length - 1].text);
+                    bindings.set(nameNode.text, identifiers[identifiers.length - 1].text, 'annotation', nameNode);
                 }
             }
             cursor = end + 1;
@@ -1703,12 +1759,15 @@ function extractCallsFromTokenTree(tree, enclosingFunction, calls, getReceiverTy
                 ? ({ string_literal: 'str', raw_string_literal: 'str',
                     char_literal: 'char', boolean_literal: 'bool' })[recvTok.type]
                 : undefined;
-            const receiverType = (receiver && receiver !== 'self')
+            const receiverRootType = receiverRoot === 'self'
+                ? findEnclosingImplType(tok) : getReceiverType?.(receiverRoot, tok);
+            const receiverType = receiverField ? undefined : (receiver && receiver !== 'self')
                 ? (getReceiverType?.(receiver, tok) || inheritedTokenTypes.get(receiver))
                 : litType;
             const receiverPatternShadow = !!(receiver && isPatternShadow?.(tok, receiver));
             const receiverFlowInvalidated = !!(receiver && isFlowInvalidated?.(tok, receiver));
             const iterationSource = rustIterationSourceOf(tok, receiver);
+            const patternSource = rustPatternBindingOf(tok, receiver);
             const producer = !receiver && lastProducer &&
                 lastProducer.callEnd === recvTok?.endIndex ? lastProducer : null;
             const record = {
@@ -1719,10 +1778,12 @@ function extractCallsFromTokenTree(tree, enclosingFunction, calls, getReceiverTy
                 isMethod: true,
                 receiver: receiverField ? undefined : receiver,
                 ...(receiverField && { receiverRoot, receiverField }),
-                ...(receiverType && { receiverType }),
+                ...(receiverRootType && { receiverRootType }),
+                ...(receiverType && { receiverType, ...(getReceiverType?.(receiver, tok, true) || inheritedTokenTypes.fields(receiver, receiverType)) }),
                 ...(receiverPatternShadow && { receiverPatternShadow: true }),
                 ...(receiverFlowInvalidated && { receiverFlowInvalidated: true }),
                 ...(iterationSource || {}),
+                ...(patternSource || {}),
                 ...(producer && {
                     receiverCall: producer.name,
                     ...(producer.isMethod && { receiverCallIsMethod: true }),
@@ -1948,26 +2009,13 @@ function rustPatternBindingOf(node, receiver) {
         return identifiers.length === 1 ? identifiers[0] : null;
     };
 
-    for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
-        if (ancestor.type === 'function_item') break;
-        if (ancestor.type === 'closure_expression') {
-            const params = ancestor.childForFieldName('parameters');
-            if (params && patternContainsIdentifier(params, receiver)) break;
-            continue; // captured binding from an outer match arm
-        }
-        if (ancestor.type !== 'match_arm') continue;
-        let matchExpression = ancestor.parent;
-        while (matchExpression && matchExpression.type !== 'match_expression' &&
-            matchExpression.type !== 'function_item') {
-            matchExpression = matchExpression.parent;
-        }
-        const matchValue = matchExpression?.type === 'match_expression'
-            ? matchExpression.childForFieldName('value')
-            : null;
+    const readPattern = (root, matchValue) => {
         const source = matchValue?.type === 'identifier'
             ? { receiverPatternSourceVariable: matchValue.text }
+            : matchValue?.type === 'call_expression'
+            ? { receiverPatternSourceCallStart: matchValue.startIndex,
+                receiverPatternSourceCallEnd: matchValue.endIndex }
             : {};
-        const root = ancestor.childForFieldName('pattern');
         const pending = root ? [root] : [];
         while (pending.length > 0) {
             const pattern = pending.pop();
@@ -1976,7 +2024,19 @@ function rustPatternBindingOf(node, receiver) {
                 const positional = pattern.namedChildren
                     .filter(child => !typeNode || child.id !== typeNode.id);
                 for (let i = 0; i < positional.length; i++) {
-                    if (directBindingName(positional[i]) !== receiver) continue;
+                    const tupleProjection = (part, steps = []) => {
+                        if (directBindingName(part) === receiver) return steps;
+                        if (part.type !== 'tuple_pattern') return null;
+                        // Unnamed `_` nodes still occupy a tuple position.
+                        const elements = part.children.filter(child => !['(', ')', ','].includes(child.type));
+                        for (const [position, child] of elements.entries()) {
+                            const found = tupleProjection(child, [...steps, position]);
+                            if (found) return found;
+                        }
+                        return null;
+                    };
+                    const projection = tupleProjection(positional[i]);
+                    if (!projection) continue;
                     const pathText = typeNode?.text;
                     if (!pathText) return null;
                     const segments = pathText.split('::').filter(Boolean);
@@ -1985,6 +2045,7 @@ function rustPatternBindingOf(node, receiver) {
                     return {
                         receiverPatternVariant: variant,
                         receiverPatternIndex: i,
+                        ...(projection.length && { receiverPatternProjection: projection }),
                         ...source,
                         ...(segments.length > 0 && {
                             receiverPatternOwner: segments.join('::'),
@@ -1997,6 +2058,49 @@ function rustPatternBindingOf(node, receiver) {
             }
         }
         return null;
+    };
+
+    for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
+        if (ancestor.type === 'function_item') break;
+        if (ancestor.type === 'block') {
+            for (const child of [...ancestor.namedChildren].reverse()) {
+                if (child.endIndex > node.startIndex) continue;
+                const declaration = child.type === 'expression_statement' ? child.namedChild(0) : child;
+                const pattern = declaration?.type === 'let_declaration'
+                    ? declaration.childForFieldName('pattern')
+                    : declaration?.type === 'assignment_expression'
+                    ? declaration.childForFieldName('left') : null;
+                if (patternContainsIdentifier(pattern, receiver)) {
+                    return declaration.type === 'let_declaration' && declaration.childForFieldName('alternative')
+                        ? readPattern(pattern, declaration.childForFieldName('value')) : null;
+                }
+            }
+        }
+        if (ancestor.type === 'for_expression' &&
+            patternContainsIdentifier(ancestor.childForFieldName('pattern'), receiver)) return null;
+        if (ancestor.type === 'closure_expression') {
+            const params = ancestor.childForFieldName('parameters');
+            if (params && patternContainsIdentifier(params, receiver)) break;
+            continue; // captured binding from an outer match arm
+        }
+        let matchValue, root;
+        if (ancestor.type === 'match_arm') {
+            let matchExpression = ancestor.parent;
+            while (matchExpression && matchExpression.type !== 'match_expression' &&
+                matchExpression.type !== 'function_item') matchExpression = matchExpression.parent;
+            matchValue = matchExpression?.type === 'match_expression'
+                ? matchExpression.childForFieldName('value') : null;
+            root = ancestor.childForFieldName('pattern');
+        } else if (['if_expression', 'while_expression'].includes(ancestor.type)) {
+            const body = ancestor.childForFieldName(ancestor.type === 'if_expression' ? 'consequence' : 'body');
+            const condition = ancestor.childForFieldName('condition');
+            if (!body || node.startIndex < body.startIndex || node.endIndex > body.endIndex ||
+                condition?.type !== 'let_condition') continue;
+            matchValue = condition.childForFieldName('value');
+            root = condition.childForFieldName('pattern');
+        } else continue;
+        if (!patternContainsIdentifier(root, receiver)) continue;
+        return readPattern(root, matchValue);
     }
     return null;
 }
@@ -2067,38 +2171,6 @@ function findCallsInCode(code, parser) {
         return ['function_item', 'closure_expression'].includes(node.type);
     };
 
-    // Extract the base type name from a Rust type node (strips &, &mut, Box<>, etc.)
-    const extractTypeName = (typeNode) => {
-        if (!typeNode) return null;
-        if (typeNode.type === 'type_identifier' ||
-            typeNode.type === 'primitive_type') {
-            return typeNode.text;
-        }
-        if (typeNode.type === 'reference_type') {
-            // &Filter or &mut Filter -> Filter
-            for (let i = 0; i < typeNode.namedChildCount; i++) {
-                const r = extractTypeName(typeNode.namedChild(i));
-                if (r) return r;
-            }
-        }
-        if (typeNode.type === 'abstract_type' || typeNode.type === 'dynamic_type') {
-            for (let i = 0; i < typeNode.namedChildCount; i++) {
-                const r = extractTypeName(typeNode.namedChild(i));
-                if (r) return r;
-            }
-        }
-        if (typeNode.type === 'generic_type') {
-            // Box<Filter> -> Filter (or get the outer type)
-            return extractTypeName(typeNode.namedChild(0));
-        }
-        if (typeNode.type === 'scoped_type_identifier') {
-            // module::Type -> Type
-            const nameNode = typeNode.childForFieldName('name');
-            return nameNode?.text || null;
-        }
-        return null;
-    };
-
     const extractTypeQualifier = (typeNode) => {
         if (!typeNode) return null;
         if (typeNode.type === 'reference_type') {
@@ -2120,7 +2192,7 @@ function findCallsInCode(code, parser) {
 
     // Build type map from function parameters (including self receiver for impl methods)
     const buildScopeTypeMap = (node) => {
-        const typeMap = new Map();
+        const typeMap = new ReceiverTypeMap();
         typeMap.qualifiers = new Map();
         typeMap.iteratorItems = new Map();
         typeMap.annotationTexts = new Map();
@@ -2154,7 +2226,7 @@ function findCallsInCode(code, parser) {
                         // Pattern can be identifier or _
                         const name = patternNode.type === 'identifier' ? patternNode.text : null;
                         if (name) {
-                            typeMap.set(name, typeName);
+                            typeMap.set(name, typeName, 'annotation', param);
                             typeMap.annotationTexts.set(name, typeNode.text);
                             if (qualifier) typeMap.qualifiers.set(name, qualifier);
                             if (iteratorItem) typeMap.iteratorItems.set(name, iteratorItem);
@@ -2253,13 +2325,21 @@ function findCallsInCode(code, parser) {
         !!flowEventAt(node, varName)?.invalidated;
 
     // Look up variable type from scope chain
-    const getReceiverType = (varName, atNode) => {
+    const getReceiverType = (varName, atNode, evidence = false) => {
         if (atNode && patternShadowsAt(atNode, varName)) return undefined;
         const flow = flowEventAt(atNode, varName);
-        if (flow?.type) return flow.type;
+        if (flow?.type) {
+            const { until, ...origin } = flow;
+            return evidence ? { receiverTypeSource: 'flow',
+                receiverTypeEvidence: { ...typeOrigin('flow', atNode), ...origin,
+                    ...(Number.isFinite(until) && { until }) },
+                ...(flow.qualifier && { receiverTypeQualifier: flow.qualifier }) } : flow.type;
+        }
         for (let i = functionStack.length - 1; i >= 0; i--) {
             const typeMap = scopeTypes.get(functionStack[i].startLine);
-            if (typeMap?.has(varName)) return typeMap.get(varName);
+            if (typeMap?.has(varName)) return evidence ? { ...typeMap.fields(varName),
+                ...(typeMap.qualifiers?.has(varName) && { receiverTypeQualifier: typeMap.qualifiers.get(varName) }) }
+                : typeMap.get(varName);
             if (typeMap?.boundNames?.has(varName)) return undefined;
         }
         return undefined;
@@ -2363,15 +2443,31 @@ function findCallsInCode(code, parser) {
         };
     };
 
-    // Walk up to the enclosing impl block's target type (impl<T> Foo<T> → Foo).
-    const findEnclosingImplType = (n) => {
-        for (let p = n.parent; p; p = p.parent) {
-            if (p.type === 'impl_item') {
-                const t = p.childForFieldName('type');
-                return (t && extractTypeName(t)) || undefined;
-            }
-        }
-        return undefined;
+    const copiedBindingType = (value, assignment, retainedName = null) => {
+        let expression = value;
+        while (expression && ['reference_expression', 'parenthesized_expression'].includes(expression.type)) {
+            expression = expression.childForFieldName('value') || expression.namedChildren.at(-1);
+        }
+        const dereferenced = !retainedName && expression?.type === 'unary_expression' && expression.child(0)?.text === '*';
+        if (dereferenced) expression = expression.namedChild(0);
+        const name = retainedName || (expression?.type === 'identifier' ? expression.text : null);
+        if (!name) return null;
+        const type = getReceiverType(name, assignment);
+        const facts = type && getReceiverType(name, assignment, true);
+        if (!facts?.receiverTypeEvidence || ['unknown', 'guess'].includes(facts.receiverTypeSource)) return null;
+        const annotation = dereferenced && getReceiverAnnotationText(name, assignment);
+        // Deref on a custom owner can change the type. Only an actual
+        // reference annotation proves the built-in `&*reference` reborrow.
+        if (dereferenced && (facts.receiverTypeSource !== 'annotation' || !annotation?.trim().startsWith('&'))) return null;
+        const qualifier = getReceiverTypeQualifier(name, assignment);
+        return { type, ...(qualifier && { qualifier }), aliasBinding: {
+            variable: name, target: assignment.childForFieldName(
+                assignment.type === 'let_declaration' ? 'pattern' : 'left')?.text,
+            type, origin: facts.receiverTypeEvidence,
+            assignment: typeOrigin('flow', assignment),
+            ...(dereferenced && { referenceAnnotation: annotation }),
+            kind: retainedName ? 'reassignment' : value.type === 'identifier' ? 'copy' : 'borrow',
+        } };
     };
 
     const closureContractSource = (node) => {
@@ -2495,7 +2591,11 @@ function findCallsInCode(code, parser) {
                         at: node.endIndex,
                         until,
                         ...(() => {
-                            const inferred = matchBindingType(value, node);
+                            // Rust assignment preserves a variable's static
+                            // type; a fresh `let` may shadow it with another.
+                            const inferred = copiedBindingType(value, node,
+                                node.type === 'assignment_expression' ? pattern.text : null) ||
+                                matchBindingType(value, node);
                             return inferred
                                 ? { invalidated: false, ...inferred }
                                 : { invalidated: !valueHasFlowProducer(value) };
@@ -2761,7 +2861,7 @@ function findCallsInCode(code, parser) {
                         callEnd: node.endIndex,
                         isMethod: true,
                         receiver,
-                        ...(receiverType && { receiverType }),
+                        ...(receiverType && { receiverType, ...(getReceiverType(receiver, node, true) || { receiverTypeSource: 'unknown' }) }),
                         ...(receiverTypeQualifier && { receiverTypeQualifier }),
                         ...(receiverIteratorItemType && { receiverIteratorItemType }),
                         ...(receiverPatternShadow && { receiverPatternShadow: true }),
@@ -2987,7 +3087,7 @@ function findCallsInCode(code, parser) {
                         line: fieldNode.startPosition.row + 1,
                         isMethod: true,
                         receiver,
-                        ...(receiverType && { receiverType }),
+                        ...(receiverType && { receiverType, ...(getReceiverType(receiver, node, true) || { receiverTypeSource: 'unknown' }) }),
                         ...(receiverPatternShadow && { receiverPatternShadow: true }),
                         ...(receiverFlowInvalidated && { receiverFlowInvalidated: true }),
                         isFunctionReference: true,
@@ -3061,7 +3161,7 @@ function findCallsInCode(code, parser) {
                         }
                     }
                     if (typeName) {
-                        typeMap.set(varName, typeName);
+                        typeMap.set(varName, typeName, typeAnnotation ? 'annotation' : valueNode?.type === 'call_expression' ? 'guess' : 'constructor', typeAnnotation || valueNode);
                         if (typeQualifier) typeMap.qualifiers.set(varName, typeQualifier);
                     }
                 }
@@ -3121,7 +3221,7 @@ function findImportsInCode(code, parser) {
         const right = String(suffix || '').replace(/^::/, '');
         return left && right ? `${left}::${right}` : left || right;
     };
-    const addLeaf = (module, localName, type = 'use', dynamic = false, line) => {
+    const addLeaf = (module, localName, type = 'use', dynamic = false, line, rename = null) => {
         if (!module || !localName) return;
         imports.push({
             module,
@@ -3129,6 +3229,7 @@ function findImportsInCode(code, parser) {
             type,
             dynamic,
             line,
+            ...(rename && { renames: [rename] }),
         });
     };
     const collectUseTree = (node, prefix, line) => {
@@ -3150,13 +3251,20 @@ function findImportsInCode(code, parser) {
             const pathNode = node.namedChild(0);
             const aliasNode = node.childForFieldName('alias') || node.namedChild(1);
             if (pathNode && aliasNode) {
-                addLeaf(joinUsePath(prefix, pathNode.text), aliasNode.text,
-                    'use', false, line);
                 // fix #353: `use alpha::widget as renamed; renamed()` — the
                 // alias pairing feeds findCallers' import-rename surface
                 // (calledAs), exactly like Python/JS `import x as y`.
+                // fix #357: `renames` pairs the alias with ITS record so
+                // createImportBindings emits {name: original, alias: local}
+                // (the #348 Python shape); two renames of one source name
+                // from different modules each pair with their own module
+                // instead of both bindings matching both calls. `names`
+                // keeps the local spelling (parser contract, imports command).
                 const original = String(pathNode.text).split('::').pop();
-                if (original && original !== aliasNode.text && original !== 'self') {
+                const renamed = original && original !== aliasNode.text && original !== 'self';
+                addLeaf(joinUsePath(prefix, pathNode.text), aliasNode.text,
+                    'use', false, line, renamed ? { original, local: aliasNode.text } : null);
+                if (renamed) {
                     if (!imports.aliases) imports.aliases = [];
                     imports.aliases.push({ original, local: aliasNode.text });
                 }

package/languages/type-evidence.js

@@ -0,0 +1,63 @@
+'use strict';
+
+/** Data-only AST witness. Never retain a tree-sitter node in a call cache. */
+function typeOrigin(source = 'unknown', node = null) {
+    return {
+        source,
+        ...(node && {
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column,
+            start: node.startIndex,
+            end: node.endIndex,
+            nodeType: node.type,
+        }),
+    };
+}
+
+/**
+ * A string-valued type map with independent provenance. Existing inference
+ * keeps its Map semantics; adding witnesses must not change classification.
+ * Reassignment, deletion, and scope restoration update the witness together
+ * with the inferred type so a stale constructor can never justify a new value.
+ */
+class ReceiverTypeMap extends Map {
+    constructor(entries) {
+        super();
+        this.origins = new Map();
+        if (entries) this.restore(entries);
+    }
+
+    set(name, type, source = 'unknown', node = null) {
+        super.set(name, type);
+        this.origins.set(name, typeof source === 'object' ? { ...source } : typeOrigin(source, node));
+        return this;
+    }
+
+    delete(name) {
+        this.origins.delete(name);
+        return super.delete(name);
+    }
+
+    clear() {
+        this.origins.clear();
+        super.clear();
+    }
+
+    restore(entries) {
+        this.clear();
+        for (const [name, type] of entries) {
+            this.set(name, type, entries.origins?.get(name) || 'unknown');
+        }
+        return this;
+    }
+
+    fields(name, type = this.get(name)) {
+        const origin = type && type === this.get(name) ? this.origins.get(name) : null;
+        return {
+            receiverTypeSource: origin?.source || 'unknown',
+            ...(origin && { receiverTypeEvidence: { ...origin, name, type } }),
+        };
+    }
+}
+
+module.exports = { ReceiverTypeMap, typeOrigin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucn",
-  "version": "5.3.4",
+  "version": "5.3.6",
   "mcpName": "io.github.mleoca/ucn",
   "description": "Auditable AST code intelligence for AI agents: 18 task-oriented commands through one MCP tool, CLI, or agent skill. Supports JS/TS, Python, Go, Rust, Java, C, C++, C#, and HTML.",
   "main": "index.js",
@@ -10,7 +10,7 @@
   },
   "scripts": {
     "version": "node scripts/sync-server-version.js && git add server.json",
-    "test": "node --test test/shell-output.test.js test/parser-unit.test.js test/integration.test.js test/cache.test.js test/formatter.test.js test/interactive.test.js test/feature.test.js test/regression-js.test.js test/regression-py.test.js test/regression-go.test.js test/regression-java.test.js test/regression-rust.test.js test/regression-c-family.test.js test/regression-cross.test.js test/regression-mcp.test.js test/mcp-protocol.test.js test/mcp-sdk-compat.test.js test/dependency-security.test.js test/regression-parser.test.js test/regression-commands.test.js test/regression-fixes.test.js test/regression-bugfixes.test.js test/release-surface-regressions.test.js test/prerelease-audit.test.js test/release-readiness-audit.test.js test/cross-language.test.js test/accuracy.test.js test/command-coverage.test.js test/perf-optimizations.test.js test/performance-gate-policy.test.js test/oracle-gate-policy.test.js test/outcome-policy.test.js test/consistency-eval.test.js test/agent-public-surface-benchmark.test.js test/command-contracts.test.js test/language-adapter.test.js test/systematic-test.js test/mcp-edge-cases.js test/conservation.test.js test/parity-test.js test/trust-matrix.test.js",
+    "test": "node --test test/evidence-provenance.test.js test/provenance-unit.test.js test/shell-output.test.js test/parser-unit.test.js test/integration.test.js test/cache.test.js test/formatter.test.js test/interactive.test.js test/feature.test.js test/regression-js.test.js test/regression-py.test.js test/regression-go.test.js test/regression-java.test.js test/regression-rust.test.js test/regression-c-family.test.js test/regression-cross.test.js test/regression-mcp.test.js test/mcp-protocol.test.js test/mcp-sdk-compat.test.js test/dependency-security.test.js test/regression-parser.test.js test/regression-commands.test.js test/regression-fixes.test.js test/regression-bugfixes.test.js test/release-surface-regressions.test.js test/prerelease-audit.test.js test/release-readiness-audit.test.js test/cross-language.test.js test/accuracy.test.js test/command-coverage.test.js test/perf-optimizations.test.js test/performance-gate-policy.test.js test/oracle-gate-policy.test.js test/outcome-policy.test.js test/consistency-eval.test.js test/agent-public-surface-benchmark.test.js test/command-contracts.test.js test/language-adapter.test.js test/systematic-test.js test/mcp-edge-cases.js test/conservation.test.js test/parity-test.js test/trust-matrix.test.js",
     "benchmark:agent": "node test/agent-public-surface-benchmark.js",
     "benchmark:agent:gate": "node test/agent-public-surface-benchmark.js --gate",
     "benchmark:agent:legacy": "node test/agent-understanding-benchmark.js",