ucn 5.3.0 → 5.3.1

package/.claude/skills/ucn/SKILL.md

@@ -69,6 +69,16 @@ identity; matching attribute syntax with an unresolved receiver stays
 unverified. These are change dependencies, not fabricated caller edges, so
 the caller `ACCOUNT` remains a call-shaped partition.
 
+When the selected definition is a type, interface, enum, trait, or record,
+`impact` adds a `TYPE REFERENCE SITES` band: annotation and reference sites
+confirmed by an import link to the definition's file (or package scope in
+Go/Java), the rest visible as unverified with a reason. `DEPENDENCY SITES`
+counts them; `CALL SITES` stays call-shaped.
+
+Target-less `impact` and `check` diff the working tree against `HEAD` AND
+include untracked, non-ignored source files as whole-file additions, so new
+modules are checked before `git add`. `--staged` keeps its index-only meaning.
+
 An observed-text zero is not semantic zero or safe-delete proof. Numeric evidence values are ordinal ranking weights, not probabilities.
 
 When a plain name selects more than one definition, action-oriented commands

package/core/analysis.js

@@ -980,6 +980,113 @@ function related(index, name, options = {}) {
  * @param {object} options - { file, className, exclude, top }
  * @returns {object|null}
  */
+// Kinds whose dependents are annotation/reference sites rather than calls.
+// Classes and structs stay out: `new X()` / `X{}` are call-shaped and already
+// flow through the caller sweep.
+const TYPE_REFERENCE_KINDS = new Set(['type', 'interface', 'enum', 'trait', 'record']);
+
+/**
+ * fix #345: tiered annotation-site band for a type-kind definition.
+ * Confirmed needs identity evidence: same file as the definition, or an
+ * import binding of the name in the referencing file that reaches the
+ * definition's file (the #215/#217 scope discipline). Anything else is
+ * VISIBLE unverified with a reason. A same-name definition elsewhere is
+ * excluded as other-target. Spelling alone never confirms.
+ */
+function findTypeReferences(index, name, def, options = {}) {
+    if (!def || !TYPE_REFERENCE_KINDS.has(def.type)) return null;
+    const { usages } = require('./search');
+    const { _importReaches, _sameNominalPackageDir } = require('./callers');
+    const records = usages(index, name, {
+        includeTests: true, codeOnly: true, exclude: options.exclude,
+    });
+    const targetFiles = new Set([def.file]);
+    const sameNameDefs = (index.symbols.get(name) || []).filter(d => d !== def);
+    const confirmed = [];
+    const unverified = [];
+    const excluded = [];
+    for (const u of (Array.isArray(records) ? records : records?.usages || [])) {
+        if (u.isDefinition || u.usageType !== 'reference') continue;
+        const site = {
+            file: u.relativePath, line: u.line,
+            expression: (u.content || '').trim(),
+        };
+        // A same-name type defined in the referencing file owns that file's
+        // bare references (the #215 scope rule): excluded, never confirmed.
+        if (u.file !== def.file && sameNameDefs.some(d => d.file === u.file && TYPE_REFERENCE_KINDS.has(d.type))) {
+            excluded.push({ ...site, reason: 'other-definition' });
+            continue;
+        }
+        if (sameNameDefs.some(d => d.file === u.file && (d.nameLine || d.startLine) === u.line)) {
+            excluded.push({ ...site, reason: 'other-definition' });
+            continue;
+        }
+        if (u.file === def.file) {
+            confirmed.push({ ...site, evidence: 'same-file' });
+            continue;
+        }
+        const fileEntry = index.files.get(u.file);
+        // Directory-scoped packages (Go) and Java packages see sibling files'
+        // types without an import; a same-name def in another package would
+        // have been excluded above only if it shared the line, so require the
+        // pinned def to be the package's own.
+        const packageScoped = fileEntry && (
+            (langTraits(fileEntry.language).packageScope === 'directory' &&
+                path.dirname(u.file) === path.dirname(def.file)) ||
+            (fileEntry.language === 'java' &&
+                _sameNominalPackageDir(path.dirname(def.file), path.dirname(u.file), 'java')));
+        if (packageScoped) {
+            const foreign = sameNameDefs.some(d => TYPE_REFERENCE_KINDS.has(d.type) &&
+                path.dirname(d.file) === path.dirname(u.file));
+            if (foreign) unverified.push({ ...site, reason: 'same-package-ambiguous' });
+            else confirmed.push({ ...site, evidence: 'package-scope' });
+            continue;
+        }
+        const bindings = (fileEntry?.importBindings || []).filter(b =>
+            b.name === name || b.alias === name);
+        if (bindings.length > 0) {
+            const reaches = bindings.some(b => {
+                const rel = fileEntry.moduleResolved && fileEntry.moduleResolved[b.module];
+                return rel && _importReaches(index, path.join(index.root, rel), targetFiles);
+            });
+            if (reaches) { confirmed.push({ ...site, evidence: 'import' }); continue; }
+            const otherProject = bindings.some(b =>
+                fileEntry.moduleResolved && fileEntry.moduleResolved[b.module]);
+            if (otherProject) { excluded.push({ ...site, reason: 'other-definition-import' }); continue; }
+            unverified.push({ ...site, reason: 'import-unresolved' });
+            continue;
+        }
+        if (fileEntry?.importNames?.includes('*')) {
+            unverified.push({ ...site, reason: 'star-import' });
+            continue;
+        }
+        unverified.push({ ...site, reason: 'no-import-link' });
+    }
+    if (confirmed.length === 0 && unverified.length === 0 && excluded.length === 0) {
+        return { owner: def.type, confirmedCount: 0, unverifiedCount: 0, totalCandidates: 0,
+            byFile: [], unverifiedSites: [], excluded: { total: 0, byReason: {} } };
+    }
+    const bySite = (a, b) => a.file !== b.file ? codeUnitCompare(a.file, b.file) : a.line - b.line;
+    confirmed.sort(bySite); unverified.sort(bySite);
+    const byFile = new Map();
+    for (const site of confirmed) {
+        if (!byFile.has(site.file)) byFile.set(site.file, []);
+        byFile.get(site.file).push(site);
+    }
+    return {
+        owner: def.type,
+        confirmedCount: confirmed.length,
+        unverifiedCount: unverified.length,
+        totalCandidates: confirmed.length + unverified.length,
+        byFile: [...byFile.entries()].map(([file, sites]) => ({ file, count: sites.length, sites })),
+        unverifiedSites: unverified,
+        excluded: {
+            total: excluded.length,
+            byReason: excluded.reduce((out, s) => { out[s.reason] = (out[s.reason] || 0) + 1; return out; }, {}),
+        },
+    };
+}
+
 function impact(index, name, options = {}) {
     index._beginOp();
     try {
@@ -1270,6 +1377,13 @@ function impact(index, name, options = {}) {
         };
     }
 
+    // fix #345: a type/interface/enum/trait is consumed through annotations,
+    // not calls. Those sites were counted in the ACCOUNT as references and
+    // listed nowhere, so the headline said 0 for a type with dozens of
+    // dependents. Same design as the accessor band: a separate band, never
+    // fake caller edges (the caller oracle and the account stay call-shaped).
+    let typeReferences = findTypeReferences(index, name, def, options);
+
     // Apply top limit if specified (limits total call sites shown)
     const totalBeforeLimit = filteredSites.length;
     if (options.top && options.top > 0 && filteredSites.length > options.top) {
@@ -1315,6 +1429,8 @@ function impact(index, name, options = {}) {
         ...Array.from(byFile.keys()),
         ...(propertyAccesses?.byFile || []).map(group => group.file),
         ...(propertyAccesses?.unverifiedSites || []).map(site => site.file),
+        ...(typeReferences?.byFile || []).map(group => group.file),
+        ...(typeReferences?.unverifiedSites || []).map(site => site.file),
     ]);
 
     return {
@@ -1332,6 +1448,11 @@ function impact(index, name, options = {}) {
             totalDependencySites: totalBeforeLimit + propertyAccesses.confirmedCount,
             affectedFiles: affectedFiles.size,
         }),
+        ...(typeReferences && {
+            typeReferences,
+            totalDependencySites: totalBeforeLimit + typeReferences.confirmedCount,
+            affectedFiles: affectedFiles.size,
+        }),
         account: impactAccount,
         hasEntrypoints: !!impactReachable && impactReachable.size > 0,
         callerHistogram,
@@ -1876,19 +1997,6 @@ function diffImpact(index, options = {}) {
         }
     }
 
-    if (!diffText || !diffText.trim()) {
-        return {
-            base: staged ? '(staged)' : base,
-            changedPaths: 0,
-            nonSourcePaths: 0,
-            functions: [],
-            moduleLevelChanges: [],
-            newFunctions: [],
-            deletedFunctions: [],
-            summary: { modifiedFunctions: 0, deletedFunctions: 0, newFunctions: 0, totalCallSites: 0, unverifiedCallSites: 0, affectedFiles: 0 }
-        };
-    }
-
     // Diff paths are git-root-relative. Resolve to index.root for file lookup.
     // Normalize both through realpath to handle macOS /var → /private/var symlinks.
     let realGitRoot, realProjectRoot;
@@ -1908,6 +2016,58 @@ function diffImpact(index, options = {}) {
         changes.push({ ...c, gitRelativePath: c.relativePath, filePath: path.join(index.root, localRel), relativePath: localRel });
     }
 
+    // fix #346: untracked files are new work too. `git diff <base>` only
+    // sees tracked paths, so a session's brand-new modules were invisible to
+    // the pre-commit gate until `git add -N` — a silent pass on exactly the
+    // code that has never been checked. Indexed, gitignore-respecting
+    // untracked source files join the working-tree diff as whole-file
+    // additions (staged mode keeps its index-only meaning).
+    let untrackedPaths = 0;
+    if (!staged) {
+        const lsArgs = ['ls-files', '--others', '--exclude-standard', '-z'];
+        if (file) lsArgs.push('--', file);
+        let untrackedText = '';
+        try {
+            untrackedText = execFileSync('git', lsArgs, {
+                cwd: index.root, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024,
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+        } catch (_) { untrackedText = ''; }
+        const known = new Set(changes.map(c => c.relativePath));
+        for (const localRel of untrackedText.split('\0').filter(Boolean).sort(codeUnitCompare)) {
+            if (known.has(localRel)) continue;
+            const filePath = path.join(index.root, localRel);
+            const fileEntry = index.files.get(filePath);
+            if (!fileEntry || !detectLanguage(filePath)) continue;
+            let lineCount = fileEntry.lines;
+            if (!Number.isFinite(lineCount)) {
+                try { lineCount = fs.readFileSync(filePath, 'utf-8').split('\n').length; } catch (_) { continue; }
+            }
+            const addedLines = [];
+            for (let i = 1; i <= lineCount; i++) addedLines.push(i);
+            untrackedPaths++;
+            changes.push({
+                filePath, relativePath: localRel,
+                gitRelativePath: projectPrefix ? `${projectPrefix}/${localRel}` : localRel,
+                addedLines, deletedLines: [], untracked: true,
+            });
+        }
+    }
+
+    if (changes.length === 0) {
+        return {
+            base: staged ? '(staged)' : base,
+            changedPaths: 0,
+            nonSourcePaths: 0,
+            untrackedPaths: 0,
+            functions: [],
+            moduleLevelChanges: [],
+            newFunctions: [],
+            deletedFunctions: [],
+            summary: { modifiedFunctions: 0, deletedFunctions: 0, newFunctions: 0, totalCallSites: 0, unverifiedCallSites: 0, affectedFiles: 0 }
+        };
+    }
+
     const functions = [];
     const moduleLevelChanges = [];
     const newFunctions = [];
@@ -2111,7 +2271,10 @@ function diffImpact(index, options = {}) {
             const { symbol, addedLines } = data;
             const identityKey = `${symbol.name}\0${symbol.className || ''}`;
             let isNew;
-            if (oldSymbolIdentities !== null) {
+            if (change.untracked) {
+                // fix #346: nothing in an untracked file existed at the base.
+                isNew = true;
+            } else if (oldSymbolIdentities !== null) {
                 isNew = !oldSymbolIdentities.has(identityKey);
             } else {
                 // Fallback: 80% of body lines added and no deletions hit this symbol.
@@ -2291,6 +2454,7 @@ function diffImpact(index, options = {}) {
         base: staged ? '(staged)' : base,
         changedPaths: changes.length,
         nonSourcePaths,
+        untrackedPaths,
         functions,
         moduleLevelChanges,
         newFunctions,

package/core/callers.js

@@ -16128,4 +16128,4 @@ function findCallbackUsages(index, name) {
     return usages;
 }
 
-module.exports = { _unresolvedModuleIsGap, getCachedCalls, findCallers, findCallees, getInstanceAttributeTypes, findCallbackUsages, _nameBindingReaches, _moduleAttributeBindingReaches, _declaredFieldType, _projectTopLevelNames, _callArityCompatible, _closeCallableIdentityGroup, _overloadDiscipline, _overloadApplicable };
+module.exports = { _unresolvedModuleIsGap, _importReaches, _sameNominalPackageDir, getCachedCalls, findCallers, findCallees, getInstanceAttributeTypes, findCallbackUsages, _nameBindingReaches, _moduleAttributeBindingReaches, _declaredFieldType, _projectTopLevelNames, _callArityCompatible, _closeCallableIdentityGroup, _overloadDiscipline, _overloadApplicable };

package/core/check.js

@@ -88,9 +88,9 @@ function check(index, options = {}) {
         const nonSourcePaths = dr?.nonSourcePaths || 0;
         let reason = 'no changes detected';
         if (changedPaths > 0 && nonSourcePaths === changedPaths) {
-            reason = `${changedPaths} changed path(s), all outside supported source files`;
+            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';
+            reason = 'no callable-symbol changes in the diff or untracked source files';
         }
         return {
             base: options.base || 'HEAD',

package/core/output/analysis-ext.js

@@ -215,6 +215,10 @@ function formatDiffImpact(result, options = {}) {
     if (result.nonSourcePaths > 0) {
         lines.push(`Note: ${result.nonSourcePaths} changed path(s) outside supported source files not analyzed.`);
     }
+    // fix #346: untracked source files join the working-tree diff.
+    if (result.untrackedPaths > 0) {
+        lines.push(`Note: ${result.untrackedPaths} untracked source file(s) included as whole-file additions.`);
+    }
     lines.push('');
 
     // Modified functions

package/core/output/analysis.js

@@ -786,8 +786,8 @@ function formatImpact(impact, options = {}) {
     // Summary (confirmed + unverified tiers reported separately)
     const impactUnverified = impact.unverifiedSites || [];
     const unverifiedSuffix = impactUnverified.length > 0 ? ` confirmed + ${impactUnverified.length} unverified` : '';
-    if (impact.propertyAccesses) {
-        const pa = impact.propertyAccesses;
+    if (impact.propertyAccesses || impact.typeReferences) {
+        const pa = impact.propertyAccesses || impact.typeReferences;
         const uv = pa.unverifiedCount ? ` + ${pa.unverifiedCount} unverified` : '';
         lines.push(`DEPENDENCY SITES: ${impact.totalDependencySites} confirmed${uv}`);
     }
@@ -885,6 +885,34 @@ function formatImpact(impact, options = {}) {
         }
     }
 
+    // fix #345: annotation sites of a type-kind definition, tiered like the
+    // accessor band. The headline no longer says 0 for a type with dependents.
+    if (impact.typeReferences) {
+        const refs = impact.typeReferences;
+        lines.push(`${compact ? '' : '\n'}TYPE REFERENCE SITES: ${refs.confirmedCount} confirmed` +
+            (refs.unverifiedCount ? ` + ${refs.unverifiedCount} unverified` : '') +
+            (refs.excluded?.total ? ` (${refs.excluded.total} other-target)` : ''));
+        for (const group of refs.byFile) {
+            for (const site of group.sites) {
+                const expr = site.expression ? `: ${site.expression.replace(/\s+/g, ' ').slice(0, 100)}` : '';
+                lines.push(`  ${group.file}:${site.line}${expr}`);
+            }
+        }
+        if (refs.unverifiedSites.length > 0) {
+            lines.push(`${compact ? '' : '\n'}UNVERIFIED TYPE REFERENCE CANDIDATES (${refs.unverifiedSites.length}) — name matches, no import link to this definition:`);
+            for (const site of refs.unverifiedSites.slice(0, 10)) {
+                const expr = site.expression ? `: ${site.expression.replace(/\s+/g, ' ').slice(0, 100)}` : '';
+                lines.push(`  ${site.file}:${site.line}${expr} (${site.reason})`);
+            }
+            if (refs.unverifiedSites.length > 10) {
+                lines.push(`  (+${refs.unverifiedSites.length - 10} more unverified)`);
+            }
+        }
+        if (refs.confirmedCount === 0 && refs.unverifiedCount === 0) {
+            lines.push('  (no annotation sites outside the definition)');
+        }
+    }
+
     // 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:`);

package/core/output/endpoints.js

@@ -84,7 +84,7 @@ function formatRoutesAndRequests(routes, requests, meta, options, advisory = nul
 
     if (showClient) {
         if (requests.length === 0) {
-            if (showServer) lines.push('No client requests detected.');
+            if (showServer) lines.push('Client Requests: 0 — no static route literal found in any indexed file (wrapped or dynamically built request paths are invisible to this scan).');
         } else {
             if (showServer) lines.push('');
             lines.push(`Client Requests: ${requests.length}`);

package/core/output/lines.js

@@ -184,6 +184,7 @@ function impactRecords(result) {
         const summary = result.summary || {};
         notes.push(`# Diff: ${summary.modifiedFunctions || 0} modified, ${summary.newFunctions || 0} new, ${summary.deletedFunctions || 0} deleted functions; ${(result.moduleLevelChanges || []).length} file(s) with module-level changes.`);
         if (result.nonSourcePaths) notes.push(`# ${result.nonSourcePaths} changed path(s) outside supported source files not analyzed.`);
+        if (result.untrackedPaths) notes.push(`# ${result.untrackedPaths} untracked source file(s) included as whole-file additions.`);
         return { records: [...new Set(out)], notes };
     }
     for (const group of result.byFile || []) {
@@ -207,6 +208,18 @@ function impactRecords(result) {
         }
         notes.push(`# PROPERTY ACCESS SITES: ${accesses.confirmedCount} confirmed, ${accesses.unverifiedCount} unverified, ${accesses.excluded?.total || 0} other-target (separate from caller ACCOUNT).`);
     }
+    if (result.typeReferences) {
+        const refs = result.typeReferences;
+        for (const group of refs.byFile || []) {
+            for (const site of group.sites || []) {
+                out.push(record(group.file, site.line, site.expression, 'type-reference'));
+            }
+        }
+        for (const site of refs.unverifiedSites || []) {
+            out.push(record(pathOf(site), site.line, site.expression, `unverified: ${site.reason}; type-reference`));
+        }
+        notes.push(`# TYPE REFERENCE SITES: ${refs.confirmedCount} confirmed, ${refs.unverifiedCount} unverified, ${refs.excluded?.total || 0} other-target (separate from caller ACCOUNT).`);
+    }
     notes.push(...accountComments(result.account));
     for (const warning of result.warnings || []) notes.push(...commentLines(warning.message));
     if (result.scopeWarning?.hint) notes.push(...commentLines(result.scopeWarning.hint));

package/core/output/tracing.js

@@ -532,6 +532,14 @@ function formatReverseTraceJson(result) {
 /**
  * Format affected-tests command output - text
  */
+// fix #347: a hub symbol at depth 2 links hundreds of names per test file;
+// the list is the answer only for leaves. Cap at 8 unless --all.
+function linkList(names, options) {
+    const MAX_LINKS = options?.all ? Infinity : 8;
+    if (!Array.isArray(names) || names.length <= MAX_LINKS) return (names || []).join(', ');
+    return `${names.slice(0, MAX_LINKS).join(', ')}, +${names.length - MAX_LINKS} more`;
+}
+
 function formatAffectedTests(result, options = {}) {
     if (!result) return 'Function not found.';
 
@@ -553,7 +561,7 @@ function formatAffectedTests(result, options = {}) {
         lines.push(`Test files to run (${summary.totalTestFiles}):`);
         lines.push('');
         for (const tf of displayFiles) {
-            lines.push(`  ${tf.file} (links: ${tf.linkedFunctions.join(', ')})`);
+            lines.push(`  ${tf.file} (links: ${linkList(tf.linkedFunctions, options)})`);
             // Show up to 5 key matches per file
             const keyMatches = tf.matches
                 .filter(m => m.matchType === 'call' || m.matchType === 'test-case')
@@ -581,7 +589,7 @@ function formatAffectedTests(result, options = {}) {
             lines.push(`  Additional test files (${pat.length}):`);
             const MAX_POSSIBLE = options.all ? Infinity : 10;
             for (const tf of pat.slice(0, MAX_POSSIBLE)) {
-                lines.push(`    ${tf.file} (links: ${tf.linkedFunctions.join(', ')})`);
+                lines.push(`    ${tf.file} (links: ${linkList(tf.linkedFunctions, options)})`);
             }
             if (pat.length > MAX_POSSIBLE) {
                 lines.push(`    ... ${pat.length - MAX_POSSIBLE} more (${options.allHint || 'use --all'})`);

package/languages/python.js

@@ -1317,34 +1317,59 @@ function pythonTargetBindsName(left, name) {
     return false;
 }
 
-function pythonScopeBindsName(scopeNode, name) {
-    for (let i = 0; i < scopeNode.namedChildCount; i++) {
-        const child = scopeNode.namedChild(i);
-        if (child.type === 'function_definition' ||
-            child.type === 'async_function_definition' ||
-            child.type === 'class_definition') {
-            // The nested body is a separate scope, but the declaration name
-            // binds in this scope.
-            if (child.childForFieldName('name')?.text === name) return true;
-            continue;
+// One walk per scope body collects every name it binds at this scope level
+// (declarations, assignment targets, for/with targets; nested def/class bodies
+// are separate scopes, lambdas too). Memoized per tree by native node id: the
+// caller loop asks the same body about many names, and a per-name walk made
+// the Python build cost functions x tracked names x body size (measured 10s of
+// a 60s sequential build on a 20MB Python repo).
+const scopeBoundNamesByTree = new WeakMap();
+function pythonScopeBoundNames(scopeNode) {
+    let byId = scopeBoundNamesByTree.get(scopeNode.tree);
+    if (!byId) { byId = new Map(); scopeBoundNamesByTree.set(scopeNode.tree, byId); }
+    const cached = byId.get(scopeNode.id);
+    if (cached) return cached;
+    const names = new Set();
+    const addTarget = (left) => {
+        if (!left) return;
+        if (left.type === 'identifier') names.add(left.text);
+        else if (left.type === 'pattern_list' || left.type === 'tuple_pattern') {
+            for (const item of left.namedChildren) {
+                if (item.type === 'identifier') names.add(item.text);
+            }
         }
-        if (child.type === 'lambda') continue;
-        if (child.type === 'assignment' ||
-            child.type === 'augmented_assignment' ||
-            child.type === 'named_expression') {
-            if (pythonTargetBindsName(
-                child.childForFieldName('left') || child.childForFieldName('name'),
-                name)) return true;
-        } else if (child.type === 'for_statement') {
-            if (pythonTargetBindsName(child.childForFieldName('left'), name)) return true;
-        } else if (child.type === 'with_statement') {
-            const text = child.namedChild(0)?.text || '';
-            const match = text.match(/\bas\s+([A-Za-z_][A-Za-z0-9_]*)/);
-            if (match && match[1] === name) return true;
-        }
-        if (pythonScopeBindsName(child, name)) return true;
-    }
-    return false;
+    };
+    const walk = (node) => {
+        for (const child of node.namedChildren) {
+            if (child.type === 'function_definition' ||
+                child.type === 'async_function_definition' ||
+                child.type === 'class_definition') {
+                const declared = child.childForFieldName('name')?.text;
+                if (declared) names.add(declared);
+                continue;
+            }
+            if (child.type === 'lambda') continue;
+            if (child.type === 'assignment' ||
+                child.type === 'augmented_assignment' ||
+                child.type === 'named_expression') {
+                addTarget(child.childForFieldName('left') || child.childForFieldName('name'));
+            } else if (child.type === 'for_statement') {
+                addTarget(child.childForFieldName('left'));
+            } else if (child.type === 'with_statement') {
+                const text = child.namedChild(0)?.text || '';
+                const match = text.match(/\bas\s+([A-Za-z_][A-Za-z0-9_]*)/);
+                if (match) names.add(match[1]);
+            }
+            walk(child);
+        }
+    };
+    walk(scopeNode);
+    byId.set(scopeNode.id, names);
+    return names;
+}
+
+function pythonScopeBindsName(scopeNode, name) {
+    return pythonScopeBoundNames(scopeNode).has(name);
 }
 
 const PY_COMPREHENSIONS = new Set([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucn",
-  "version": "5.3.0",
+  "version": "5.3.1",
   "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",