ucn 5.0.6 → 5.2.0

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
@@ -53,7 +53,7 @@ not an accuracy grade.
 For caller-bearing `show`, `impact`, `trace`, `tests`, and `check` views:
 
 - `CONFIRMED` has binding, receiver, import, or ownership evidence for the pinned target.
-- `UNVERIFIED` is a possible target with insufficient identity evidence. Review it before a breaking change.
+- `UNVERIFIED` is a possible target with insufficient identity evidence. Review it before a breaking change. When same-name definitions cause the ambiguity, `show` lists their stable handles once above the sites so the competing targets are explicit.
 - `ACCOUNT` partitions observed literal-name lines into confirmed, unverified, non-call, excluded, and unresolved buckets. In mixed-language repositories it also counts occurrences in unsupported-language source files.
 - `CONTRACT` states the scope and completeness of that observed-text partition. When unsupported-language files contain the name, it says so explicitly and the partition-complete claim is limited to supported languages.
 - `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.
@@ -114,9 +114,16 @@ 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. Read `changeSummary` and every review item. `plan` previews only: it does
+not modify files, run a compiler, or prove runtime compatibility.
 
 ## Efficient use
 

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

@@ -25,7 +25,7 @@ structural or code-only search.
 | `impact [handle]` | Show direct symbol impact when given a handle; without one, 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, 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. |
 
 ## Repository and architecture
 
@@ -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/.claude/skills/ucn/references/trust-contract.md

@@ -41,16 +41,17 @@ Even when all eight hold, `account.contract.semanticComplete` remains false. Use
 
 Semantic recall can be complete while the result is still impractical: a true edge may be present only in a large unverified set. Release evaluation therefore measures both placement and the amount of review an agent must perform.
 
-- `trueEdgeUnverifiedRate` is the share of semantic oracle edges found only in the unverified tier.
+- `trueEdgeUnverifiedRate` is the share of statically exact oracle edges found only in the unverified tier. Runtime-polymorphic, compiler-dependent template, and oracle-unresolved references remain in the all-oracle view but never inflate the exact denominator.
 - `zeroActionableUnverifiedTargetRate` is the share of reviewed targets with no actionable ambiguity.
 - `actionableUnverifiedCandidatesP50`, `actionableUnverifiedCandidatesP95`, and `actionableUnverifiedCandidatesMax` measure actionable candidate-set size per target.
 - `unverifiedReviewItemsPerOracleEdge` measures effective review work relative to the oracle workload. Actionable false candidates count individually; each named runtime-dispatch family counts once.
 - `rawFalseUnverifiedPerOracleEdge` preserves the ungrouped false-candidate amplification for auditability.
+- `runtimeDependentOracleEdges`, `compilerDependentOracleEdges`, and `oracleAbstentionEdges` disclose why all-oracle coverage is broader than exact target identity.
 - `unverifiedReasons` groups candidates by the engine reason that kept them out of the confirmed tier.
 
 Configuration-gated candidates remain visible but are not labeled false when the compiler/LSP oracle did not score them. The raw JSON rollup is the source of truth for these fields; the Markdown report is generated from the same data.
 
-The publish-blocking portable-AST ceilings are: at most 10% of exact true edges left unverified, at most 20% within any sufficiently sampled symbol kind, at least 80% of targets with zero actionable ambiguity, actionable-candidate p95 at most five, and at most 0.10 effective review items per oracle edge. The semantic gate separately requires 100% in-scope recall, at least 98% confirmed-tier precision, full conservation, and 100% public-command proof recall. Passing these sampled floors is release evidence, not runtime-completeness proof.
+The publish-blocking portable-AST ceilings are: at most 10% of exact true edges left unverified, at most 20% within any sufficiently sampled symbol kind, at least 80% of targets with zero actionable ambiguity, actionable-candidate p95 at most five, and at most 0.10 effective review items per oracle edge. The semantic gate separately requires 100% in-scope recall, at least 98% confirmed-tier precision, full conservation, and 100% public-command proof recall. Three class-aware floors gate at zero: unaccounted oracle edges of the exact, runtime-dispatch, and oracle-unresolved classes (caller and callee arms; compile-time-dispatch attributions stay report-only because their non-exact band varies with the compiler oracle's environment), runtime-dispatch oracle edges excluded with reason (possible-dispatch routing is demote-only), and deferred oracle-unresolved edges that exact definition lookup pins to the target re-enter the gate-bearing universe. Passing these sampled floors is release evidence, not runtime-completeness proof.
 
 The performance gate runs each pinned repository in three independent processes with a fixed worker shape. Publish and PR gates require both CPU and wall-throughput floors on the median run, pin the expected file/LOC workload, and use the worst observed build/full-board peak RSS so memory failures cannot be averaged away. Exploratory one-process runs keep wall throughput diagnostic. Scoped reports are separate from the full release artifact; the dated rollup is release-qualified only when every required row came from a full release invocation. The composite release gate runs this stage first so verbose compiler-oracle output and report consumers cannot perturb its samples.
 

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.
@@ -299,8 +302,17 @@ 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. 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
+compiler and test suite. Before committing, point the same machinery at your
 Git diff:
 
 ```bash
@@ -518,10 +530,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,
@@ -638,7 +653,9 @@ answers. It's guidance over the same engine, not a second implementation.
   and external consumers can be invisible. UCN reports these blind spots
   (`repo --sections=health --deep`) rather than pretending they don't exist.
 - Interface, trait, template, overload, and untyped-receiver dispatch may stay
-  in the UNVERIFIED tier with a reason instead of being guessed.
+  in the UNVERIFIED tier with a reason instead of being guessed. When
+  same-name definitions compete, `show` lists their stable handles once so
+  agents can see exactly what needs disambiguation.
 - C/C++ analysis doesn't run the preprocessor or compiler; build-specific
   branches, advanced templates, and macro expansion can remain unresolved. C#
   analysis doesn't run Roslyn; source generators and external assembly

package/core/analysis.js

@@ -12,7 +12,8 @@ const path = require('path');
 const { execFileSync } = require('child_process');
 const { parse } = require('./parser');
 const { detectLanguage, langTraits } = require('../languages');
-const { NON_CALLABLE_TYPES, addTestExclusions, countTextBlindspots, codeUnitCompare } = require('./shared');
+const { NON_CALLABLE_TYPES, addTestExclusions, countTextBlindspots,
+    codeUnitCompare, formatSymbolHandle } = require('./shared');
 const { isTestFile } = require('./discovery');
 const { computeReachability, symbolKey } = require('./entrypoints');
 const { getLanguageAdapter } = require('../languages');
@@ -23,6 +24,62 @@ const { projectComputedDispatch } = require('./ast-analysis');
 // passed to one of these (the common pattern in mocha/jest/vitest).
 const _JS_TEST_FRAMEWORK_CALLS = new Set(['describe', 'it', 'test', 'spec', 'context', 'suite']);
 
+/**
+ * Give agents the exact indexed definitions behind a same-name ambiguity.
+ * Candidate handles live once on the context result rather than being copied
+ * onto every unverified site (a single broad name can have thousands).
+ */
+function buildAmbiguityCandidates(index, name, selected, unverified) {
+    const relevant = (unverified || []).filter(site =>
+        site.reason === 'method-ambiguous' || site.reason === 'ambiguous-binding');
+    if (relevant.length === 0) return null;
+    const byHandle = new Map();
+    for (const definition of (index.symbols.get(name) || [])) {
+        if (!definition.file || !definition.startLine) continue;
+        const handle = formatSymbolHandle(definition);
+        if (handle && !byHandle.has(handle)) byHandle.set(handle, definition);
+    }
+    const definitions = [...byHandle.values()]
+        .sort((a, b) => {
+            const aSelected = a.bindingId === selected.bindingId ||
+                (a.file === selected.file && a.startLine === selected.startLine);
+            const bSelected = b.bindingId === selected.bindingId ||
+                (b.file === selected.file && b.startLine === selected.startLine);
+            if (aSelected !== bSelected) return aSelected ? -1 : 1;
+            const fileCmp = codeUnitCompare(a.relativePath || a.file, b.relativePath || b.file);
+            if (fileCmp !== 0) return fileCmp;
+            if (a.startLine !== b.startLine) return a.startLine - b.startLine;
+            return codeUnitCompare(a.type, b.type);
+        });
+    if (definitions.length < 2) return null;
+    const limit = 12;
+    const items = definitions.slice(0, limit).map(definition => ({
+        handle: formatSymbolHandle(definition),
+        type: definition.type,
+        ...(definition.className && { owner: definition.className }),
+        ...(!definition.className && definition.receiver && {
+            owner: definition.receiver.replace(/^\*/, ''),
+        }),
+        ...(!definition.className && !definition.receiver && definition.assignedReceiver && {
+            owner: definition.assignedReceiver,
+            memberAssignment: true,
+        }),
+        selected: definition.bindingId === selected.bindingId ||
+            (definition.file === selected.file && definition.startLine === selected.startLine),
+    }));
+    // reduce, not Math.max(...spread): a broad name on a monorepo can carry
+    // enough unverified sites to overflow the argument list.
+    const dispatchOwners = relevant.reduce(
+        (max, site) => Math.max(max, Number(site.dispatchCandidates) || 0), 0);
+    return {
+        name,
+        totalDefinitions: definitions.length,
+        ...(dispatchOwners > 0 && { dispatchOwners }),
+        items,
+        truncated: definitions.length > items.length,
+    };
+}
+
 /**
  * Tag each call site with `inTestCase` based on its enclosing function's
  * entry-point classification. Uses each language's `getEntryPointKind`
@@ -338,6 +395,8 @@ function context(index, name, options = {}) {
 
         typeCallers = [...typeCallers].sort(byFileLine);
         typeUnverified = [...typeUnverified].sort(byFileLine);
+        const typeAmbiguityCandidates = buildAmbiguityCandidates(
+            index, name, def, typeUnverified);
 
         const callerTotal = typeCallers.length;
         if (options.maxCallers && options.maxCallers > 0) {
@@ -366,6 +425,9 @@ function context(index, name, options = {}) {
             // Also include places where the type is used in function parameters/returns
             callers: typeCallers,
             unverifiedCallers: typeUnverified,
+            ...(typeAmbiguityCandidates && {
+                ambiguityCandidates: typeAmbiguityCandidates,
+            }),
             meta: { account: typeAccount, callerTotal }
         };
 
@@ -485,6 +547,8 @@ function context(index, name, options = {}) {
 
     const callerHistogram = buildHistogram(callers);
     const calleeHistogram = buildHistogram(callees);
+    const ambiguityCandidates = buildAmbiguityCandidates(
+        index, name, def, unverifiedCallers);
     const callerTotal = callers.length;
     const calleeTotal = callees.length;
     if (options.maxCallers && options.maxCallers > 0) {
@@ -512,6 +576,7 @@ function context(index, name, options = {}) {
         returnType: def.returnType,
         callers,
         unverifiedCallers,
+        ...(ambiguityCandidates && { ambiguityCandidates }),
         callees,
         unverifiedCallees: rawCallees.unverifiedCallees || [],
         callerHistogram,

package/core/bridge.js

@@ -835,7 +835,8 @@ function collectProjectRouterMounts(index) {
                     const targetEntry = index.files.get(targetFile);
                     if (targetEntry) {
                         const exportedReceivers = (targetEntry.exportDetails || [])
-                            .filter(exp => exp.type === 'module.exports' || exp.isDefault ||
+                            .filter(exp => (exp.type === 'module.exports' && exp.defaultLike) ||
+                                exp.isDefault ||
                                 exp.kind === 'default' || exp.type === 'export-default' ||
                                 exp.name === ref.name)
                             .map(exp => exp.localName || exp.name).filter(Boolean);

package/core/cache.js

@@ -599,7 +599,52 @@ function clearAllCaches() {
 // v166: C++ nested aliases persist their lexical owner ranges, and `auto`
 // return functions persist a unanimously inferred local concrete type. v165
 // was used during prerelease development before both fields were complete.
-const CACHE_FORMAT_VERSION = 167;
+// v173: JS/TS fluent methods persist AST-proven `this` return identity, and
+// nested const/arrow callables persist their enclosing lexical owner range.
+// v172: immutable JS/TS class-member aliases materialize their local and
+// exported callable identities, preserving declared return types through
+// factory aliases and chained receivers.
+// v171: import bindings persist their syntactic kind (named/default/namespace)
+// so an exported ESM namespace object can carry exact member ownership through
+// a downstream named or default import.
+// v170: statically-owned CommonJS property assignments persist their local
+// callable identity, allowing exact module ownership to exclude a different
+// same-name export without treating all CJS surfaces as opaque.
+// v169: CommonJS export details distinguish the value assigned directly to
+// module.exports (`defaultLike`) from property exports; this prevents a
+// namespace require from becoming a confirmed call to every exported member.
+// v168: JS/TS one-hop member-assignment defs persist assignedReceiver — the
+// 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).
+// 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).
+const CACHE_FORMAT_VERSION = 188;
 
 /**
  * Save index to cache file
@@ -640,7 +685,9 @@ function saveCache(index, cachePath) {
     // Strip redundant fields from symbols and file entries to reduce cache size.
     // v6: All paths stored as relative paths (saves ~60% on large codebases).
     // symbol.file = path.join(root, symbol.relativePath) — reconstructable
-    // symbol.bindingId = relativePath:type:startLine — reconstructable
+    // Default symbol.bindingId = relativePath:type:startLine — reconstructable.
+    // Preserve non-default IDs: synthetic declarations can share a source line
+    // and need their explicit identity to survive a cache round-trip.
     // fileEntry.path = Map key — redundant
     // fileEntry.relativePath = now the Map key — redundant
     const root = index.root;
@@ -648,6 +695,12 @@ function saveCache(index, cachePath) {
     for (const [name, defs] of index.symbols) {
         const stripped = defs.map(s => {
             const { file, bindingId, ...rest } = s;
+            const defaultBindingId = s.relativePath && s.type && s.startLine
+                ? `${s.relativePath}:${s.type}:${s.startLine}`
+                : null;
+            if (bindingId && bindingId !== defaultBindingId) {
+                rest.bindingId = bindingId;
+            }
             return rest;
         });
         strippedSymbols.push([name, stripped]);
@@ -897,12 +950,15 @@ function loadCache(index, cachePath) {
                 const fileEntry = index.files.get(s.file);
                 if (fileEntry) {
                     fileEntry.symbols.push(s);
-                    fileEntry.bindings.push({
-                        id: s.bindingId,
-                        name: s.name,
-                        type: s.type,
-                        startLine: s.startLine
-                    });
+                    if (!s.memberAssigned && !s.bodyScopedName && !s.exportedAlias &&
+                        s.type !== 'impl') {
+                        fileEntry.bindings.push({
+                            id: s.bindingId,
+                            name: s.name,
+                            type: s.type,
+                            startLine: s.startLine
+                        });
+                    }
                 }
             }
         }