ucn 5.1.1 → 5.2.1

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

@@ -41,7 +41,7 @@ three. The text block is the whole response on every surface.
 
 Persistent indexes live in a per-user, project-keyed cache rather than the analyzed repository. Set `UCN_CACHE_DIR` to override the cache root; CLI `--no-cache` bypasses persistence and `--clear-cache` removes the current project's cache. Legacy `<project>/.ucn-cache` directories are migrated on first use.
 
-Supported source families are JavaScript/TypeScript/TSX, Python, Go, Rust, Java, C, C++, C#, and HTML inline JavaScript/event handlers. C/C++ uses `compile_commands.json` when available to classify headers and resolve include paths. Recoverable preprocessor branches contribute AST-proven source facts, so a single selected configuration does not silently erase definitions or calls; UCN still cannot prove which branch a particular build activates. This is portable AST analysis, not a compiler build; macros, templates, generated code, reflection, and external dependency semantics can remain unverified.
+Supported source families are JavaScript/TypeScript/TSX, Python, Go, Rust, Java, C, C++, C#, and HTML inline JavaScript/event handlers. C/C++ uses `compile_commands.json` when available to classify headers and resolve include paths. Recoverable preprocessor branches contribute AST-proven source facts, so a single selected configuration does not silently erase definitions or calls; disagreeing conditional macro identities stay visible as unverified. C++ resolution uses namespace ownership, static overload shape (including arrays), and macro-parameter requalification. C# resolution uses declared property/field receiver types plus overload and hiding discipline. This is portable AST analysis, not a compiler build; macros, templates, generated code, reflection, and external dependency semantics can remain unverified.
 
 `repo` readiness is task-specific. Its headline is navigation readiness;
 refactor, deletion, semantic recall, and the sampled evidence mix are separate
@@ -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
@@ -114,9 +120,24 @@ rejected, and unsupported advanced syntax should be handed to ripgrep.
 call candidates. Calls proved to belong to another same-name target are
 disclosed separately and excluded from the activity total.
 
-`plan` always includes the selected declaration plus indexed call/import/export
-previews. Read `changeSummary`, and manually review any edit marked
-`needsReview`; the command previews changes but does not apply or compile them.
+For `plan --rename-to`, the selected declaration is only the starting point.
+When the index proves the relationship, the rename unit closes over
+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.
+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. 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, including the selected declaration and indexed call/import/export sites. Review `changeSummary` and `needsReview`. |
+| `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. |
 
@@ -84,4 +84,4 @@ Omit the target for the current project. A target may be a file, directory, or q
 
 ## Language notes
 
-Supported source families are JavaScript/TypeScript/TSX, Python, Go, Rust, Java, C, C++, C#, and HTML inline JavaScript/event handlers. C/C++ consumes `compile_commands.json` when present for header-language and include-path context, and retains AST-proven facts across recoverable preprocessor branches. UCN remains portable AST analysis: it does not run a compiler, preprocessor, Roslyn, or an LSP during normal queries, and it does not assert which conditional branch a build activates.
+Supported source families are JavaScript/TypeScript/TSX, Python, Go, Rust, Java, C, C++, C#, and HTML inline JavaScript/event handlers. C/C++ consumes `compile_commands.json` when present for header-language and include-path context, and retains AST-proven facts across recoverable preprocessor branches. C++ call identity uses namespace ownership, static overload shape (including arrays), and macro requalification; disagreeing conditional macro definitions remain visible as unverified. C# uses declared property/field receiver types and overload/hiding discipline. UCN remains portable AST analysis: it does not run a compiler, preprocessor, Roslyn, or an LSP during normal queries, and it does not assert which conditional branch a build activates.

package/README.md

@@ -39,6 +39,8 @@ It's deliberately lightweight:
 
 - **No required background process** - the CLI parses on demand, answers, and
   exits. MCP stays warm only when you choose to run it.
+- **No HTTP or network stack** - MCP uses a local, dependency-free stdio
+  transport; UCN never opens a port.
 - **No language servers, no compilation** - tree-sitter does the analysis
   without building the project.
 - **No config** - point it at a directory and ask.
@@ -200,7 +202,7 @@ ACCOUNT, CONTRACT, and WARNING lines survive the cut.
 Don't take the tiers on faith. Release gates re-derive UCN's answers from real
 compilers and language servers on a ten-repository board of pinned production
 codebases, and publishing is blocked unless they pass. The latest full
-release-board run (2026-08-11):
+release-board run (2026-08-24):
 
 | Repository | Pinned commit | Oracle | Caller precision | Caller recall | Callee prec / recall | Command checks |
 |---|---|---|---:|---:|---:|---:|
@@ -211,16 +213,16 @@ release-board run (2026-08-11):
 | [ripgrep](https://github.com/BurntSushi/ripgrep) | [`82313cf9`](https://github.com/BurntSushi/ripgrep/commit/82313cf95849bfe425109ad9506a52154879b1b1) | rust-analyzer | 100% | 100% | 100% / 100% | 100% |
 | [clap](https://github.com/clap-rs/clap) | [`d3e59a9a`](https://github.com/clap-rs/clap/commit/d3e59a9ab214910b9dad02921b7ef42c6400de9b) | rust-analyzer | 100% | 100% | 100% / 100% | 100% |
 | [javapoet](https://github.com/square/javapoet) | [`b9017a95`](https://github.com/square/javapoet/commit/b9017a9503b76e11b4ad4c1a9f050e2d29112cb0) | JDT LS | 100% | 100% | 100% / 100% | 100% |
-| [newtonsoft-json](https://github.com/JamesNK/Newtonsoft.Json) | [`4f73e743`](https://github.com/JamesNK/Newtonsoft.Json/commit/4f73e74372445108d2c1bda37b36e6f5e43402e0) | Roslyn | 99.4% | 100% | 100% / 100% | 100% |
+| [newtonsoft-json](https://github.com/JamesNK/Newtonsoft.Json) | [`4f73e743`](https://github.com/JamesNK/Newtonsoft.Json/commit/4f73e74372445108d2c1bda37b36e6f5e43402e0) | Roslyn | 100% | 100% | 100% / 100% | 100% |
 | [cjson](https://github.com/DaveGamble/cJSON) | [`c859b25d`](https://github.com/DaveGamble/cJSON/commit/c859b25da02955fef659d658b8f324b5cde87be3) | clangd | 100% | 100% | 100% / 100% | 100% |
-| [fmt](https://github.com/fmtlib/fmt) | [`e424e3f2`](https://github.com/fmtlib/fmt/commit/e424e3f2e607da02742f73db84873b8084fc714c) | clangd | 99.6% | 100% | 100% / 100% | 100% |
+| [fmt](https://github.com/fmtlib/fmt) | [`e424e3f2`](https://github.com/fmtlib/fmt/commit/e424e3f2e607da02742f73db84873b8084fc714c) | clangd | 100% | 100% | 100% / 100% | 100% |
 
 On the same run: **zero** in-scope oracle call edges missing from the answer
 (the release gate) on every repository, **zero** false-dead `deadcode` claims
 in the oracle-visible sample, **8,000 / 8,000** cross-command consistency
 comparisons in agreement, **10 / 10** repositories inside the performance
-budget (slowest median cold build 15.4K lines/second by wall time, worst query
-p95 73.8 ms, highest peak RSS 771 MB), and 3,383 automated tests with no
+budget (slowest normalized median cold build 17.4K lines/second by wall time,
+worst query p95 83.0 ms, highest peak RSS 908.5 MB), and 3,609 automated tests with no
 failures or skips. The same gates run in CI (the scheduled
 [Eval workflow](https://github.com/mleoca/ucn/actions/workflows/eval.yml) and
 every release tag), and `npm run trust:gate` reproduces the release board
@@ -234,10 +236,11 @@ external population. Unverified precision is reported separately and is
 intentionally much lower on dispatch-heavy code: those entries are review
 candidates, never confirmed claims.
 
-Beyond the publish gate, a scheduled board re-checks 22 pinned repositories
+Beyond the publish gate, a scheduled board re-checks 24 pinned repositories
 across every supported oracle language (zod, express, hono, zustand, fastify,
-rich, click, grpc-go, chi, cursive, gson, jsoup, and friends), plus a rotating
-fresh-repo arm of codebases the engine was never tuned on. Repositories that
+rich, click, attrs, grpc-go, chi, cursive, itertools, gson, jsoup, and
+friends), plus a rotating fresh-repo arm of codebases the engine was never
+tuned on. Repositories that
 expose a gap stay on the board; they don't get removed to keep a table pretty.
 These are measured results on pinned code, not a claim of universal program
 understanding or identical performance on every machine.
@@ -284,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:
 
@@ -299,8 +302,21 @@ cli/index.js (2 changes)
 ... (more changes in core/discovery.js, core/cache.js, core/project.js, test/integration.test.js)
 ```
 
-Anything `plan` can't represent safely is marked `needsReview` instead of
-being silently rewritten. Before committing, point the same machinery at your
+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. 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. 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:
 
 ```bash
@@ -396,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.
 
@@ -414,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
@@ -518,10 +542,13 @@ evidence.
 - **C** - functions, structs, macros, includes, calls, entry points, API
   analysis.
 - **C++** - C coverage plus classes, methods, constructors, inheritance,
-  namespaces, overloads, templates, typed field receivers.
+  namespaces, overloads, templates, typed field receivers, static array-shape
+  selection, and macro requalification. Conditional macro disagreement stays
+  visible as unverified.
 - **C#** - namespaces, classes/interfaces/records, fields/properties,
-  attributes, overload-aware calls, async flow, top-level programs, .NET stack
-  frames, ASP.NET/HttpClient endpoints.
+  attributes, declared property/field receiver types, overload and hiding
+  discipline, async flow, top-level programs, .NET stack frames, and
+  ASP.NET/HttpClient endpoints.
 - **HTML** - inline JavaScript and `on*` event handlers.
 
 For C and C++, a `compile_commands.json` improves header-language,

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/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,
 };

package/core/cache.js

@@ -617,7 +617,38 @@ function clearAllCaches() {
 // object they patch (`console.log = fn` → 'console') — so the builtin-global
 // exclusion can see cross-file that a project def rebinds the global's
 // member (fix #286a); impl-kind symbols leave the bindings table (#286b).
-const CACHE_FORMAT_VERSION = 173;
+// v177: C++ `template <>` full-specialization defs persist isSpecialization
+// (fix #299A — identity closure with the primary template), and C++
+// argument-position calls through a local callable variable record kind
+// 'expr' instead of call:NAME (fix #299B shadow guard).
+// v178: extendsGraph entries persist the defining symbol's startLine so
+// scope-aware consumers can pick the right def when several same-name
+// classes live in one file — function-local test subclasses (fix #300,
+// attrs-measured); Go range VALUE variables are typed from the container's
+// element type (declared fields/params/vars/literals — `for _, route :=
+// range r.routes` types route as Route; fix #300, mux-measured), changing
+// persisted call-record receiverTypes.
+// v179: Go unnamed interface parameters are retained in paramsStructured;
+// old caches report zero-arity interface methods and break rename closure.
+// v183: Go calls persist exact spans, builtin-new receiver types, indexed
+// multi-return assignment targets, and lexical-closure result hints for exact
+// chain/tuple flow; Rust macro-token calls retain compiler-declared closure
+// parameter receiver types, and Rust functions retain generic trait bounds.
+// v184: Python constructor-result records no longer retain a receiverType
+// inferred from an uppercase name that is value-bound in the lexical scope
+// (fix #304).  Reject v183 calls shards so stale false receiver evidence
+// cannot survive an engine upgrade.
+// v185: C# deep member receivers retain their root+field path instead of a
+// false terminal receiverType copied from the root variable (fix #305).
+// v188: C++ call records retain enclosing macro-argument positions and macro
+// symbols retain AST-derived parameter qualification/forwarding effects, so
+// replacement-list requalification cannot masquerade as lexical calls
+// (fix #306).
+// v189: Python import records retain function-local/deferred scope so cycle
+// reporting can classify import-time vs lazy edges from fresh and cached
+// indexes; C# properties retain property identity instead of masquerading as
+// ordinary fields for accessor impact/refactoring.
+const CACHE_FORMAT_VERSION = 189;
 
 /**
  * Save index to cache file