ucn 5.2.0 → 5.2.2

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

@@ -59,6 +59,12 @@ For caller-bearing `show`, `impact`, `trace`, `tests`, and `check` views:
 - `WARNING` identifies unreadable, unparsed, or partially indexed files, and lists unsupported-language occurrence sites (file:line plus the line text) so nothing grep would show is hidden. `usages` and `tests` carry the same disclosure as a note.
 - `FILTERED` means query options hid evidence.
 
+When the selected definition is a property/getter/setter, `impact` adds a
+separate `PROPERTY ACCESS SITES` band. Confirmed reads/writes have receiver
+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.
+
 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
@@ -101,7 +107,7 @@ definition as an implicit repository-wide target.
 
 ## Deletion protocol
 
-Treat `deadcode` as a candidate generator. Before deletion, inspect `usages`, `impact`, `entrypoints`, `api`, and `repo --sections=health --deep`; then corroborate with the compiler/type checker and tests. Computed dispatch such as `handlers[key]()` is a reported blind spot; registry members reached by a modeled computed receiver are withheld. Unknown decorators/annotations and member-assigned event handlers are also withheld by default because they can be the registration itself. All remaining candidates are still review-only. Never delete solely from `deadcode` or an observed-text-zero result.
+Treat `deadcode` as a candidate generator. Before deletion, inspect `usages`, `impact`, `entrypoints`, `api`, and `repo --sections=health --deep`; then corroborate with the compiler/type checker and tests. Computed dispatch such as `handlers[key]()` is a reported blind spot; registry members reached by a modeled computed receiver are withheld. Statically named reflection such as `getattr(obj, "run")` is positive liveness evidence, so every matching member spelling is withheld; recognized dynamic reflection is counted and warned because it cannot be attributed to one member. Unknown decorators/annotations and member-assigned event handlers are also withheld by default because they can be the registration itself. All remaining candidates are still review-only. Never delete solely from `deadcode` or an observed-text-zero result.
 
 `usages` includes comment/string/docstring occurrences in an `OTHER TEXT` section unless
 `--code-only` is set. This is a literal-name inventory, not exact target
@@ -122,8 +128,16 @@ imports/exports, Python `__all__` strings, and module-attribute references.
 Exact token/expression spans keep a foreign same-named occurrence on the same
 line unchanged. Open external interfaces, incomplete ownership, unresolved
 dispatch, or an inexact token route to `needsReview` instead of a synthesized
-edit. Read `changeSummary` and every review item. `plan` previews only: it does
-not modify files, run a compiler, or prove runtime compatibility.
+edit. Comment/string occurrences in indexed source appear in `reviewItems` and
+are never rewritten automatically; the result also tells you to search
+documentation, configuration, generated files, and unsupported languages for
+the old spelling. Read `changeSummary` and every review item. `plan` previews
+only: it does not modify files, run a compiler, or prove runtime compatibility.
+
+For `deps --cycles`, `eager` means every edge executes at module scope.
+`deferred` means at least one Python edge is function-local, so the chain is
+not an unconditional import-time cycle; it remains visible because invoking
+that function during initialization can still matter.
 
 ## Efficient use
 

package/.claude/skills/ucn/references/commands.md

@@ -22,17 +22,17 @@ structural or code-only search.
 
 | Command | Purpose |
 |---|---|
-| `impact [handle]` | Show direct symbol impact when given a handle; without one, analyze the Git diff. |
+| `impact [handle]` | Show direct symbol impact when given a handle; accessor targets include receiver-tiered property reads/writes as a separate dependency band. Without a handle, analyze the Git diff. |
 | `tests <handle\|file>` | Find statically linked direct tests. Set `--depth=N` for transitive affected tests. Empty results are not runtime coverage proof. |
 | `check [handle]` | Validate confirmed call-site arity for a symbol; without one, run the composed pre-commit diagnostic. |
-| `plan <handle>` | Preview `--rename-to`, `--add-param`, or `--remove-param` edits. For renames, the proven closure can include overload/signature groups, inheritance/trait/Go-interface slots, exact call/reference tokens, imports/exports, Python `__all__` strings, and module-attribute references. Open ownership or method sets stay `needsReview`; the command never applies or compiles edits. |
+| `plan <handle>` | Preview `--rename-to`, `--add-param`, or `--remove-param` edits. For renames, the proven closure can include overload/signature groups, inheritance/trait/Go-interface slots, accessor reads/writes, exact call/reference tokens, imports/exports, Python `__all__` strings, and module-attribute references. Source comments/strings are explicit `reviewItems`; non-source files get a search handoff. Open ownership or method sets stay `needsReview`; the command never applies or compiles edits. |
 
 ## Repository and architecture
 
 | Command | Purpose |
 |---|---|
 | `repo` | Repository orientation. Select `summary,files,stats,health` with `--sections`; `--deep` includes readiness evidence. Skipped unsupported source is listed with a grep/language-tool handoff. |
-| `deps <file>` | File dependency graph. Use `--direction=imports\|importers\|both`, `--detailed`, or `--cycles`. |
+| `deps <file>` | File dependency graph. Use `--direction=imports\|importers\|both`, `--detailed`, or `--cycles`. Python cycles are classified as eager or function-local/deferred without dropping either kind. |
 | `api [file]` | Static exported/public surface for a project or file. |
 | `entrypoints` | Framework, route, task, test, and runtime entry points. |
 | `endpoints` | Server/client HTTP surface; `--bridge` adds advisory matching. |
@@ -41,7 +41,7 @@ structural or code-only search.
 
 | Command | Purpose |
 |---|---|
-| `deadcode` | Conservative unreferenced-symbol candidates for review. Modeled computed-dispatch members, unknown decorated/annotated callables, and member-assigned event handlers are withheld by default. |
+| `deadcode` | Conservative unreferenced-symbol candidates for review. Statically named reflection targets, modeled computed-dispatch members, unknown decorated/annotated callables, and member-assigned event handlers are withheld by default. Recognized dynamic reflection is counted and warned because it cannot be attributed. |
 | `audit-async` | Potential missing-await sites in JavaScript/TypeScript/Python and C#. MCP spelling: `audit_async`. |
 | `stacktrace <text>` | Advisory stack-frame parsing and source lookup. |
 

package/README.md

@@ -287,7 +287,7 @@ SIGNATURE CHANGE:
 
 CHANGES NEEDED: 12
   Files affected: 5
-  Definition 1, calls/references 7, imports 4, exports 0; manual review required for 0 of these changes
+  Definition 1, calls 7, references 0, text dependencies 0, imports 4, exports 0; manual review items 0
 
 BY FILE:
 
@@ -306,12 +306,16 @@ For a rename, `plan` closes the change over every relationship the index can
 prove: overload/signature groups, base and override declarations, Rust trait
 slots, Go interface slots and their satisfiers, exact call and value-reference
 tokens, imports/exports, Python `__all__` strings, and module-attribute
-references. It edits exact token or expression spans, so another same-named
-call on the same line is not swept up accidentally.
+references. Accessor renames also follow receiver-proven property reads and
+writes. It edits exact token or expression spans, so another same-named call
+on the same line is not swept up accidentally.
 
 Open external interfaces, incomplete ownership, unresolved dispatch, or an
 inexact token are marked `needsReview` instead of receiving a synthesized
-edit. `plan` previews changes; it does not modify files or replace the
+edit. Comments and strings in indexed source appear as separate review items
+and are never rewritten automatically; documentation, configuration,
+generated files, and unsupported languages get an explicit exact-text search
+handoff. `plan` previews changes; it does not modify files or replace the
 compiler and test suite. Before committing, point the same machinery at your
 Git diff:
 
@@ -408,7 +412,10 @@ Three claims, and every one is re-checked against rust-analyzer in CI: a
 default-audit claim with an oracle-visible reference fails the build. Notice
 what it *didn't* claim: exported API that external code may call,
 framework-registered symbols, and anything whose name appears in files UCN
-couldn't parse. `deadcode` is deliberately a candidate generator. Before
+couldn't parse. A literal reflection target such as `getattr(obj, "run")`
+also withholds matching member names from deletion candidates; recognized
+dynamic reflection is counted and warned because it cannot be attributed.
+`deadcode` is deliberately a candidate generator. Before
 deleting, corroborate with `usages`, `impact`, `api`, and your compiler and
 tests.
 
@@ -426,6 +433,11 @@ ucn entrypoints --type=http            # runtime and framework roots
 ucn endpoints --bridge --unmatched     # server routes with no client, and vice versa
 ```
 
+Cycle output separates eager import-time loops from Python chains containing
+a function-local/deferred edge. Deferred chains stay visible—they are not
+unconditional import-time cycles, but can still fail if invoked while modules
+are initializing.
+
 `endpoints --bridge` matches server routes to client requests across
 languages: Express/Fastify/Koa/NestJS/Next.js, Flask/FastAPI, Spring/JAX-RS,
 Go net/http (Gin/Echo/Chi/Fiber), axum/actix-web, and ASP.NET on the server

package/cli/index.js

@@ -760,6 +760,9 @@ function runProjectCommand(rootDir, command, arg) {
         if (flags.cache && (needsCacheSave || index.callsCacheDirty || index.reachabilityDirty || index.computedDispatchDirty)) {
             try { index.saveCache(); } catch (e) { /* best-effort */ }
         }
+        if (flags.cache && index.usageCacheDirty) {
+            try { index.saveUsageCache(); } catch (e) { /* best-effort */ }
+        }
     }
 }
 

package/core/accessors.js

@@ -0,0 +1,183 @@
+'use strict';
+
+const path = require('path');
+const { codeUnitCompare } = require('./shared');
+
+// Descriptors/properties are consumed through reads and writes, not only
+// call syntax. Keep this vocabulary shared by impact and refactoring so the
+// two commands cannot disagree about whether a selected symbol is an accessor.
+const ACCESSOR_KINDS = new Set([
+    'property', 'setter', 'deleter', 'get', 'set',
+    'static get', 'static set', 'override get', 'override set',
+    'static override get', 'static override set',
+]);
+
+function isAccessorDefinition(definition) {
+    return !!definition && (ACCESSOR_KINDS.has(definition.type) ||
+        ACCESSOR_KINDS.has(definition.memberType));
+}
+
+function ownerName(definition) {
+    if (definition.className) return definition.className;
+    if (!definition.receiver) return null;
+    return String(definition.receiver)
+        .replace(/^[*&]\s*/, '')
+        .replace(/^mut\s+/, '')
+        .replace(/<.*$/, '')
+        .trim() || null;
+}
+
+function bareTypeName(value) {
+    if (!value) return null;
+    return String(value)
+        .replace(/^(?:typing\.)?(?:Optional|Annotated|Final)\s*\[/, '')
+        .replace(/[<[(].*$/s, '')
+        .split(/\.|::/).pop()
+        .replace(/[?*&\s]/g, '') || null;
+}
+
+function typeMatchesOwner(index, typeName, contextFile, owner, ownerFile) {
+    const bare = bareTypeName(typeName);
+    if (!bare || !owner || bare !== owner) return false;
+    const resolved = index._resolveClassFile?.(bare, contextFile);
+    if (resolved) return path.resolve(resolved) === path.resolve(ownerFile);
+    const ownerDefs = (index.symbols.get(owner) || []).filter(symbol =>
+        ['class', 'struct', 'interface', 'trait', 'record'].includes(symbol.type));
+    return ownerDefs.length === 1 &&
+        path.resolve(ownerDefs[0].file) === path.resolve(ownerFile);
+}
+
+function insideSelectedAccessorBody(index, name, definition, file, line) {
+    return (index.symbols.get(name) || []).some(candidate =>
+        isAccessorDefinition(candidate) &&
+        candidate.file === definition.file &&
+        candidate.className === definition.className &&
+        file === candidate.file &&
+        line >= candidate.startLine &&
+        line <= (candidate.endLine || candidate.startLine));
+}
+
+/**
+ * Find reads/writes that may consume a selected accessor. Confirmed entries
+ * require receiver identity (`self`/`this` in the owner or a Python instance
+ * field whose constructor assignment proves the owner type). Everything else
+ * remains visible in the unverified tier; accessor identity is never guessed
+ * from the spelling alone.
+ */
+function findAccessorReferences(index, name, definition, options = {}) {
+    if (!isAccessorDefinition(definition)) return null;
+    const owner = ownerName(definition);
+    if (!owner) return null;
+
+    const confirmed = [];
+    const unverified = [];
+    const excluded = [];
+    // Use the parser's raw occurrence records rather than usages()' public
+    // line-oriented inventory. A line can contain two same-spelled member
+    // accesses with different receivers; collapsing them by file+line would
+    // make a rename edit one token while silently losing the other.
+    const refs = [];
+    for (const [file, entry] of index.files) {
+        if (!index.matchesFilters(entry.relativePath, options)) continue;
+        let content;
+        let occurrences;
+        try {
+            content = index._readFile(file);
+            if (!content.includes(name)) continue;
+            occurrences = index._getCachedUsages(file, name);
+        } catch { continue; }
+        if (!occurrences) continue;
+        const lines = content.split('\n');
+        for (const usage of occurrences) {
+            if (usage.usageType !== 'reference') continue;
+            refs.push({
+                ...usage,
+                file,
+                relativePath: entry.relativePath,
+                content: lines[usage.line - 1] || '',
+            });
+        }
+    }
+
+    for (const ref of refs) {
+        const rel = ref.relativePath || path.relative(index.root, ref.file);
+        const shaped = {
+            file: rel,
+            absoluteFile: ref.file,
+            line: ref.line,
+            expression: (ref.content || '').trim(),
+            ...(Number.isInteger(ref.column) && { column: ref.column }),
+            ...(ref.receiver && { receiver: ref.receiver }),
+        };
+
+        // A backing-store attribute inside the selected getter/setter body
+        // often has the same spelling (`self._local.value`). It is not a
+        // consumption of the descriptor being queried.
+        if (insideSelectedAccessorBody(index, name, definition, ref.file, ref.line) &&
+            !['self', 'cls', 'this'].includes(ref.receiver)) {
+            excluded.push({ ...shaped, reason: 'accessor-definition-body' });
+            continue;
+        }
+
+        const enclosing = index.findEnclosingFunction(ref.file, ref.line, true);
+        const receiver = ref.receiver || null;
+        if (receiver && ['self', 'cls', 'this'].includes(receiver) &&
+            enclosing?.className === owner && enclosing.file === definition.file) {
+            confirmed.push({
+                ...shaped,
+                callerName: enclosing.name,
+                resolution: 'same-class-accessor',
+                tier: 'confirmed',
+            });
+            continue;
+        }
+
+        let receiverType = ref.receiverType || null;
+        if (!receiverType && receiver && enclosing?.className) {
+            receiverType = index.getInstanceAttributeTypes(
+                ref.file, enclosing.className)?.get(receiver) || null;
+        }
+        if (receiverType && typeMatchesOwner(
+            index, receiverType, ref.file, owner, definition.file)) {
+            confirmed.push({
+                ...shaped,
+                callerName: enclosing?.name || null,
+                receiverType,
+                resolution: 'receiver-field-type',
+                tier: 'confirmed',
+            });
+            continue;
+        }
+        if (receiver && typeMatchesOwner(index, receiver, ref.file, owner, definition.file)) {
+            confirmed.push({
+                ...shaped,
+                callerName: enclosing?.name || null,
+                receiverType: receiver,
+                resolution: 'type-qualified-accessor',
+                tier: 'confirmed',
+            });
+            continue;
+        }
+
+        unverified.push({
+            ...shaped,
+            callerName: enclosing?.name || null,
+            ...(receiverType && { receiverType }),
+            reason: receiverType ? 'receiver-type-mismatch' :
+                receiver ? 'receiver-type-unresolved' : 'nested-receiver-unresolved',
+            tier: 'unverified',
+        });
+    }
+
+    const sort = (a, b) => codeUnitCompare(a.file, b.file) || a.line - b.line;
+    confirmed.sort(sort);
+    unverified.sort(sort);
+    excluded.sort(sort);
+    return { owner, confirmed, unverified, excluded };
+}
+
+module.exports = {
+    ACCESSOR_KINDS,
+    isAccessorDefinition,
+    findAccessorReferences,
+};

package/core/account.js

@@ -36,14 +36,16 @@
  * Ground-set semantics are grep `-n -w`: unit is the (file, line) pair, each
  * line with >= 1 word-boundary match counts once, case-sensitive.
  *
- * Performance: the ground scan is one `includes()`-gated read per project file
- * per caller-command — the same I/O profile as the existing `search`/`usages`
- * commands. Deriving counts from callsCache (zero reads) was rejected because
+ * Performance: the first ground scan is one `includes()`-gated read per project
+ * file — the same I/O profile as the existing `search`/`usages` commands.
+ * Exact results are retained in a small LRU for the lifetime of one built index
+ * so context/about/impact projections of the same symbol do not rescan the
+ * project. Deriving counts from callsCache (zero reads) was rejected because
  * comments/strings/references are not in the calls cache and the contract's
  * ground set is text-defined. AST parsing (the expensive part) is restricted
- * to files containing UNCLAIMED ground lines, via the op-cached
- * `index._getCachedUsages`. No file is read twice in one command because
- * context/about/impact run inside `index._beginOp()`.
+ * to files containing UNCLAIMED ground lines, via the content-hash-keyed
+ * `index._getCachedUsages`. Build invalidation and cache bounds preserve the
+ * same answer without retaining an unbounded repository mirror.
  */
 
 'use strict';
@@ -75,6 +77,12 @@ const UNSUPPORTED_SITE_TEXT_MAX = 160;
  * }}
  */
 function computeGroundSet(index, name) {
+    if (index._groundSetCache?.has(name)) {
+        const cached = index._groundSetCache.get(name);
+        index._groundSetCache.delete(name);
+        index._groundSetCache.set(name, cached);
+        return cached.result;
+    }
     const wordRe = new RegExp('\\b' + escapeRegExp(name) + '\\b');
     const perFile = new Map();
     let total = 0;
@@ -117,7 +125,7 @@ function computeGroundSet(index, name) {
         ? index.discoveryIssues.map(issue => ({ ...issue })) : [];
     unreadableFiles.sort();
 
-    return {
+    const result = {
         total: total + unparsed.lines + unsupported.lines,
         fileCount: fileCount + unparsed.fileCount + unsupported.fileCount,
         perFile,
@@ -126,6 +134,21 @@ function computeGroundSet(index, name) {
         unreadableFiles,
         skippedSources,
     };
+    if (index._groundSetCache) {
+        const weight = result.total + result.fileCount;
+        index._groundSetCache.set(name, { result, weight });
+        index._groundSetCacheLines = (index._groundSetCacheLines || 0) + weight;
+        const maxNames = 64;
+        const maxLines = 100000;
+        while (index._groundSetCache.size > maxNames ||
+            index._groundSetCacheLines > maxLines) {
+            const oldest = index._groundSetCache.entries().next().value;
+            if (!oldest) break;
+            index._groundSetCache.delete(oldest[0]);
+            index._groundSetCacheLines -= oldest[1].weight;
+        }
+    }
+    return result;
 }
 
 /** Scan only files the parser/index could not ingest. */
@@ -300,7 +323,12 @@ function classifyGroundLines(index, name, groundSet, claimedKeys) {
 
         // Remainder: AST usage scan distinguishes import/definition/reference
         // from comment/string/skipped-token lines.
-        const usages = index._getCachedUsages(filePath, name);
+        // Call lines were classified from the complete calls cache above.
+        // Language adapters may skip usage-only call recovery here; notably,
+        // C/C++ avoids reparsing every matching macro replacement list.
+        const usages = index._getCachedUsages(filePath, name, {
+            skipCallRecovery: true,
+        });
         const byLine = new Map();
         if (Array.isArray(usages)) {
             for (const u of usages) {

package/core/analysis.js

@@ -18,6 +18,7 @@ const { isTestFile } = require('./discovery');
 const { computeReachability, symbolKey } = require('./entrypoints');
 const { getLanguageAdapter } = require('../languages');
 const { projectComputedDispatch } = require('./ast-analysis');
+const { findAccessorReferences } = require('./accessors');
 
 // JS/TS test framework helpers — calls to these bracket a test case.
 // Used to flag call sites whose enclosing function is an arrow callback
@@ -1235,6 +1236,40 @@ function impact(index, name, options = {}) {
         });
     }
 
+    // Accessors are consumed through reads/writes. They are intentionally a
+    // separate dependency band rather than fake caller edges: the caller
+    // oracle and conservation account remain call-shaped, while impact no
+    // longer hides the normal use form of a property/getter/setter.
+    let propertyAccesses = findAccessorReferences(index, name, def, {
+        includeTests: true,
+        exclude: options.exclude,
+    });
+    if (propertyAccesses) {
+        const accessByFile = new Map();
+        for (const site of propertyAccesses.confirmed) {
+            if (!accessByFile.has(site.file)) accessByFile.set(site.file, []);
+            accessByFile.get(site.file).push(site);
+        }
+        propertyAccesses = {
+            owner: propertyAccesses.owner,
+            confirmedCount: propertyAccesses.confirmed.length,
+            unverifiedCount: propertyAccesses.unverified.length,
+            totalCandidates: propertyAccesses.confirmed.length +
+                propertyAccesses.unverified.length,
+            byFile: [...accessByFile.entries()]
+                .sort((a, b) => codeUnitCompare(a[0], b[0]))
+                .map(([file, sites]) => ({ file, count: sites.length, sites })),
+            unverifiedSites: propertyAccesses.unverified,
+            excluded: {
+                total: propertyAccesses.excluded.length,
+                byReason: propertyAccesses.excluded.reduce((out, site) => {
+                    out[site.reason] = (out[site.reason] || 0) + 1;
+                    return out;
+                }, {}),
+            },
+        };
+    }
+
     // Apply top limit if specified (limits total call sites shown)
     const totalBeforeLimit = filteredSites.length;
     if (options.top && options.top > 0 && filteredSites.length > options.top) {
@@ -1276,6 +1311,12 @@ function impact(index, name, options = {}) {
         }
     }
 
+    const affectedFiles = new Set([
+        ...Array.from(byFile.keys()),
+        ...(propertyAccesses?.byFile || []).map(group => group.file),
+        ...(propertyAccesses?.unverifiedSites || []).map(site => site.file),
+    ]);
+
     return {
         function: name,
         file: def.relativePath,
@@ -1286,6 +1327,11 @@ function impact(index, name, options = {}) {
         totalCallSites: totalBeforeLimit,
         shownCallSites: filteredSites.length,
         unverifiedSites,
+        ...(propertyAccesses && {
+            propertyAccesses,
+            totalDependencySites: totalBeforeLimit + propertyAccesses.confirmedCount,
+            affectedFiles: affectedFiles.size,
+        }),
         account: impactAccount,
         hasEntrypoints: !!impactReachable && impactReachable.size > 0,
         callerHistogram,

package/core/ast-analysis.js

@@ -181,6 +181,108 @@ function computedReceiver(callee) {
     return node?.type === 'identifier' ? node.text : null;
 }
 
+const STRING_LITERAL_NODES = new Set([
+    'string', 'string_literal', 'raw_string_literal',
+    'interpreted_string_literal', 'verbatim_string_literal',
+]);
+
+function literalStringValue(node) {
+    if (!node || !STRING_LITERAL_NODES.has(node.type)) return null;
+    const content = (node.namedChildren || []).find(child =>
+        child.type === 'string_content' || child.type === 'interpreted_string_literal_content');
+    if (content) return content.text;
+    const raw = String(node.text || '');
+    const first = raw.search(/["']/);
+    if (first < 0) return null;
+    const quote = raw[first];
+    const triple = raw.slice(first, first + 3) === quote.repeat(3);
+    const width = triple ? 3 : 1;
+    if (!raw.endsWith(quote.repeat(width))) return null;
+    const value = raw.slice(first + width, -width);
+    // Escaped/interpolated member names are not a stable static spelling.
+    if (value.includes('\\') || value.includes('{') || value.includes('$')) return null;
+    return value;
+}
+
+function callShape(node) {
+    if (!['call', 'call_expression', 'invocation_expression',
+        'method_invocation'].includes(node.type)) return null;
+    const callee = node.childForFieldName('function') ||
+        node.childForFieldName('name') || node.namedChild(0);
+    const args = node.childForFieldName('arguments') ||
+        (node.namedChildren || []).find(child =>
+            ['argument_list', 'arguments', 'bracketed_argument_list'].includes(child.type));
+    return callee && args ? { callee, args: args.namedChildren || [] } : null;
+}
+
+/**
+ * Extract recognized reflection operations and classify whether their member
+ * target is a stable literal. Literal targets are positive liveness evidence;
+ * dynamic targets cannot identify one member but must still be disclosed by
+ * deletion-oriented commands.
+ */
+function reflectionSites(content, language) {
+    try {
+        const syntaxHints = {
+            python: ['getattr', 'setattr', 'hasattr', 'delattr'],
+            javascript: ['Reflect.'],
+            typescript: ['Reflect.'],
+            tsx: ['Reflect.'],
+            go: ['MethodByName', 'FieldByName'],
+            java: ['getMethod', 'getDeclaredMethod', 'getField', 'getDeclaredField'],
+            csharp: ['GetMethod', 'GetProperty', 'GetField'],
+        }[language];
+        if (!syntaxHints || !syntaxHints.some(hint => content.includes(hint))) {
+            return [];
+        }
+        const parser = getParser(language);
+        if (!parser) return [];
+        const tree = safeParse(parser, content);
+        const sites = [];
+        walkNamed(tree.rootNode, node => {
+            const call = callShape(node);
+            if (!call) return true;
+            const callee = String(call.callee.text || '');
+            let argIndex = null;
+            let kind = null;
+            if (language === 'python' &&
+                ['getattr', 'setattr', 'hasattr', 'delattr'].includes(callee)) {
+                argIndex = 1;
+                kind = callee;
+            } else if (['javascript', 'typescript', 'tsx'].includes(language) &&
+                /^(?:globalThis\.)?Reflect\.(?:get|set|has|deleteProperty)$/.test(callee)) {
+                argIndex = 1;
+                kind = callee.split('.').pop();
+            } else if (language === 'go' &&
+                /\.(?:MethodByName|FieldByName)$/.test(callee)) {
+                argIndex = 0;
+                kind = callee.split('.').pop();
+            } else if (['java', 'csharp'].includes(language) &&
+                /(?:^|\.)(?:getMethod|getDeclaredMethod|getField|getDeclaredField|GetMethod|GetProperty|GetField)$/.test(callee)) {
+                argIndex = 0;
+                kind = callee.split('.').pop();
+            }
+            if (argIndex == null || !call.args[argIndex]) return true;
+            const name = literalStringValue(call.args[argIndex]);
+            sites.push({
+                ...(name && /^[A-Za-z_$][\w$]*$/.test(name) && { name }),
+                kind,
+                line: node.startPosition.row + 1,
+                expression: node.text,
+                dynamic: !name || !/^[A-Za-z_$][\w$]*$/.test(name),
+            });
+            return true;
+        });
+        return sites;
+    } catch (_) {
+        return [];
+    }
+}
+
+function literalReflectionSites(content, language) {
+    return reflectionSites(content, language).filter(site => !site.dynamic);
+}
+
 /**
  * Find direct computed dispatch calls such as handlers[name](). Literal keys
  * are excluded because they retain a statically visible member name.
@@ -276,4 +378,6 @@ module.exports = {
     computeAstComplexity,
     computedDispatchSites,
     projectComputedDispatch,
+    reflectionSites,
+    literalReflectionSites,
 };