[danusha2345]

Problem

Some repos keep near-identical copies of a module under several source roots, for example two app flavours: module/rc2/app/src/... and module/rcpro2/app/src/.... Every symbol then has one same-named candidate per copy. findBestMatch already scores directory proximity, so on shallow trees the caller's own copy wins. The result has two flaws, though:

• Wrong target on deep trees. Proximity is capped (15 per shared folder, max 80). When two copies both share 6+ folders with the caller, they tie, and the first-indexed copy wins, which can be the other module's.
• Understated confidence. A correct pick is reported at 0.7, or 0.4 on shallow trees, as if the name were ambiguous. Only which copy is ambiguous; the name is not.

Change

In findBestMatch, only among candidates that already tie on the full existing score, and only when every candidate is a copy of one symbol (same qualified name, kind and file basename), the copy with the longest uncapped shared directory prefix with the caller wins. It must be uniquely closest; otherwise nothing changes.

• Precedence. Same file, imports, lexical scope, kind and language all keep their priority; a single candidate is never touched.
• Confidence. When the pick is that unique closest copy, it gets 0.8: above a proximity guess (0.7), below a unique name (0.9).

Measured

I indexed 12 real projects (Kotlin ×3, C, Rust ×2, Go, Python ×2, PHP, C#, Scala) with main and with this branch. Node counts are identical everywhere.

project	edges changed	exact-match edges now at 0.8
Kotlin app with two module copies	0	2,006 (its 0.7 exact-match call edges: 1,236 → 260)
Rust app	2 → 2	58
playframework	1 → 1	184
others	0	0–389

Changed edges, checked against source:

• Rust: singbox/detect.rs::locate constructs the Located of its own file. The old edge went to mihomo/detect.rs::Located.
• playframework: a test in shutdown-happy-path/src/test now instantiates its own src/main HomeController rather than another copy's.

0.8 edges: a script checked all 2,719 new 0.8 edges in the six projects that have any. Each points at the strictly closest copy, with no exceptions.

Side effect: a 0.8 name match now outranks framework resolutions scored 0.7–0.75. In these projects that happened once (the Rust case above), and it fixed a wrong edge.

Tests

New __tests__/same-module-copy-resolution.test.ts (Python, deep paths so the cap ties) covers three cases:

• each copy's caller resolves into its own copy at 0.8; this fails on main on the targets themselves;
• an equidistant caller keeps the old choice at 0.7;
• a single candidate stays at 0.9.

The full suite passes (4721), and tsc / build:kernel are clean.

🤖 Generated with Claude Code

[colbymchenry]

Thank you, @danusha2345! This landed as #2923 with you as the commit author: a call now reaches the caller's own copy of a duplicated module (at 0.8), and on spring-modulith's example apps it fixed three links that Spring's naming rule had sent to another example's copy. Your rebase onto main, which carries #1938 as #2874, resolved the shared confidence line just as we had. On top, we judge the copies among same-language candidates, keep a match of the caller itself at the proximity score, and added Kotlin and Java flavor tests, since the Python fixture calls compute() without importing it. It ships in the next release.