fix(indexer): B7 Phase 3 -- close Java this.field.method() call-graph blind spot

last_ident_segment only split a call receiver's text on `->`/`::`, never on
a plain `.`. Java's method_invocation has no `->`, so `this.types.findPetTypes()`'s
object-field text "this.types" resolved to receiver "this" instead of "types" --
tier-2 then looked up a type for the fake pseudo-variable "this", found nothing,
and silently dropped the call edge. This made edit_context/callers() blind to
every this.field.method() call in Java, reproduced live via B7's new
spring-petclinic task (4 of 5 real call sites missed, CALM's own scripted
rename arm failed the corpus's build where the naive grep arm passed).

Fixed by adding `.` as a third segment separator; added a regression test.
Also completes B7 Phase 3 (all 6 Tier-0 languages now covered) and updates
the benchmark docs/results accordingly.

Author: Your Name

benchmarks/README.md

@@ -13,7 +13,7 @@ thật; khi số đo ra ngoài kỳ vọng (vd B6 `find_callers` = 0%), báo cá
 | B4 | Token Efficiency | MCP tools vs `cat`/`grep` naive workflow | **Implemented** — [`b4_token_efficiency/`](b4_token_efficiency/) |
 | B5 | Incremental Indexing Speed | Reindex chỉ file thay đổi | Planned |
 | B6 | Tool-Call Efficiency | Số round-trip naive vs 1 MCP call (ý tưởng từ CodeGraph) | **Implemented** — [`b6_tool_call_efficiency/`](b6_tool_call_efficiency/) |
-| B7 | Task Correctness / Regression | Refactor thật (rename) trên corpus thật per-language (fd/Rust, flask/Python), oracle xác định (build/test pass + callsite recall độc lập, không LLM-judge), đếm callsite bị bỏ sót (ý tưởng từ Serena) | **Implemented (Phase 1)** — [`b7_task_correctness/`](b7_task_correctness/) |
+| B7 | Task Correctness / Regression | Refactor thật (rename) trên corpus thật per-language (fd/Rust, flask/Python, express/JS, zod/TS, gin/Go, spring-petclinic/Java), oracle xác định (build/test pass + reference recall độc lập, không LLM-judge), đếm reference bị bỏ sót (ý tưởng từ Serena) | **Implemented (Phase 1-3, all 6 languages)** — [`b7_task_correctness/`](b7_task_correctness/) |
 | B8 | Model-Tier Leveling | Model rẻ + calm tools vs model đắt không có tools, cùng task (ý tưởng từ GitNexus) | Planned |
 | B9 | Scaling Curve | Lợi thế `calm` co giãn theo quy mô repo (nhỏ → lớn) | Planned |
 | B10 | Real Competitor A/B | `calm` vs CodeGraph vs Semble — tool call thật trên cả 3 MCP server thật (không phải số tự báo cáo) | **Superseded by B11** — [`b10_real_competitor_ab/`](b10_real_competitor_ab/) (giữ lại, xem B11 cho methodology đã fix) |

benchmarks/b7_task_correctness/README.md

@@ -1,4 +1,4 @@
-# B7 — Task-Correctness benchmark (Phase 1: fd/Rust, flask/Python; Phase 2: express/JS, zod/TS, gin/Go)
+# B7 — Task-Correctness benchmark (Phase 1: fd/Rust, flask/Python; Phase 2: express/JS, zod/TS, gin/Go; Phase 3: spring-petclinic/Java)
 
 Measures whether the CALM-scripted refactor workflow (`edit_context` →
 rename at each real reference → `diff_impact`) completes a real rename task
@@ -28,6 +28,7 @@ directly:
 | javascript | express (expressjs/express) | `npm install` | `npm test` |
 | typescript | zod (colinhacks/zod) | `pnpm install` | `pnpm test` |
 | go | gin (gin-gonic/gin) | `go build ./...` | `go test ./...` |
+| java | spring-petclinic (spring-projects) | *(none — `mvn test` compiles+tests in one step)* | `./mvnw -q test -Dtest='!*IntegrationTests' -DfailIfNoTests=false` |
 
 **Go/gin was initially skipped** in this session's first Phase-2 pass — `go`
 wasn't installed and passwordless `sudo` was unavailable (verified live:
@@ -53,6 +54,17 @@ go.mod and guessing:**
   `GOTOOLCHAIN=auto` (Go's default since 1.21) transparently downloaded
   1.25.0 on first `go build`, no manual intervention needed. Verified by
   actually running the build, not assumed from the version mismatch alone.
+- spring-petclinic's Maven Wrapper + `~/.m2` cache were already warm from an
+  earlier session's language-support benchmarking, so no network/toolchain
+  install was needed for Java. The task's `test_cmd` excludes the 4
+  Testcontainers-backed `*IntegrationTests` classes (they spin up real Docker
+  MySQL/Postgres containers): a timed run including them took 2m04s on a cold
+  image cache alone, real risk against `oracle.py::run_cmd`'s fixed 300s
+  timeout given B7 runs build/test up to 3× per task (baseline + naive + calm
+  arms). Excluding them costs zero oracle coverage — verified none of the 8
+  real reference sites fall in those 4 files. `-DfailIfNoTests=false` is
+  needed because `-Dtest` exclusion-only patterns otherwise make surefire
+  treat "0 explicitly-matched classes" as a failure.
 
 ## Isolation
 
@@ -94,7 +106,7 @@ building this, in two separate iterations:
    by widening the pattern to match the bare identifier regardless of what
    follows it.
 
-## Results (all 5 tasks, current methodology)
+## Results (all 6 tasks, current methodology)
 
 | task | baseline | naive build_pass | naive recall | naive tool_calls | calm build_pass | calm recall | calm tool_calls |
 |---|---|---|---|---|---|---|---|
@@ -103,6 +115,11 @@ building this, in two separate iterations:
 | rename_gin_clean_path | green | True | 1.0 | 3 | True | 1.0 | 4 |
 | rename_express_set_charset | green | True | 1.0 | 4 | **False** | **0.667** | 4 |
 | rename_zod_prettify_error | green | True | 1.0 | 5 | **False** | **0.5** | 4 |
+| rename_petclinic_find_pet_types | green | True | 1.0 | 7 | True | 1.0 | 4 |
+
+Java's row reflects the state **after** the parser fix below — see Phase 3
+for the real bug this run found and fixed live, before this number was
+reachable.
 
 ### Phase 1 + gin (fd, flask, gin): an honest tie
 
@@ -168,6 +185,55 @@ in `parser.rs`'s JS/TS call-site extraction (property-access calls on a
 required module's bare identifier vs. a destructured bare-name call to the
 same export).
 
+### Phase 3 (spring-petclinic/Java): a real call-graph bug found and fixed
+live — `this.field.method()` calls were completely invisible
+
+`findPetTypes` (`PetTypeRepository` interface method) was picked for the same
+reasons as gin's `cleanPath`: a single, unambiguous definition, called from 2
+production files and 3 test files with no name collision (ruled out
+`Owner.getPet`, 3 overloads, and `VetRepository.findAll`, which collides with
+`JpaRepository`'s own inherited `findAll`).
+
+**First run: naive=1.0 recall/green build, calm=0.333 recall/`False` build —
+CALM's own arm broke its own rename.** `edit_context("findPetTypes")` (raw
+JSON) reported only 2 caller edges, both in `PetTypeFormatterTests.java`,
+missing `PetController.java` and `PetTypeFormatter.java` (**production code**)
+and `PetControllerTests.java`/`ClinicServiceTests.java`. The naive build
+failure output pinpointed exactly what didn't get renamed:
+`cannot find symbol: method findPetTypes()`.
+
+**Root cause, found by reading the actual call sites, not guessing:** every
+missed site calls `this.types.findPetTypes()` (`this.`-qualified field
+access); the one call CALM *did* find is the only site written as a bare
+`types.findPetTypes()` (no `this.`). That 100%-correlated split led straight
+to `crates/calm-core/src/indexer/parser.rs::last_ident_segment` — the
+function that extracts a call's receiver from Java's `method_invocation`
+"object" field text. It split on `->` (PHP) and `::` (Rust/PHP scope) but
+**never on a plain `.`** — so for the object text `"this.types"`,
+`leading_ident` walked from byte 0 and stopped at the first `.`, returning
+`"this"` instead of `"types"`. Tier-2 resolution then looked up a declared
+type for the fake pseudo-variable `"this"`, found nothing, and silently
+dropped the call edge — no fallback, no low-confidence edge, nothing. This
+makes CALM's call graph (and `edit_context`/`callers()` built on it) blind to
+**every** `this.field.method()` call in Java — one of the two idiomatic
+field-access styles, used specifically to disambiguate a field from a
+same-named constructor parameter (`this.types = types;`, exactly
+`PetTypeRepository`'s own consumers' pattern, and a very common Spring/
+enterprise-Java convention).
+
+**Fixed** by adding `.` as a third segment separator (alongside `->`/`::`),
+taking whichever separator occurs last in the text — the same "rightmost
+identifier segment" contract the function already documented, just extended
+to the one separator style it was missing. Verified additive, not a behavior
+change: PHP's `$this->helper` (no `.` in that text) and every existing
+`this`-only receiver test (`this.logIt()`, no `.` after `this`) are
+unaffected — confirmed by the full workspace test suite staying green (868
+passed) plus a new regression test
+(`test_java_this_qualified_field_call_produces_receiver_not_this`). Re-running
+the benchmark after the fix (and a `cargo build --release -p calm-cli` to
+pick it up): calm build_pass=`True`, recall=1.0, matching naive — see the
+Results table above.
+
 ### A rejected candidate, kept for the audit trail
 
 `slugify` (`packages/zod/src/v4/core/util.ts:347`) was tried first and
@@ -204,6 +270,12 @@ original read-only tool-correctness use in B12).
    `crates/calm-server/src/tools/guardrails.rs`). A naive `c.get("path")`
    would have silently returned `None` for every caller.
 6. **`slugify` name-collision task pick** — see "A rejected candidate" above.
+7. **`last_ident_segment` never split on a plain `.`** (Phase 3, spring-
+   petclinic's `findPetTypes`) — a real, previously-undiscovered call-graph
+   gap in `crates/calm-core/src/indexer/parser.rs`, not a benchmark-harness
+   bug like 1/2 above. See "Phase 3" above for the full root-cause. Fixed in
+   `last_ident_segment` + a new regression test
+   (`test_java_this_qualified_field_call_produces_receiver_not_this`).
 
 ## Running it
 
@@ -226,10 +298,11 @@ which is not committed and safe to delete between runs.
 
 ## Next steps
 
-1. **spring-petclinic/Java** (Phase 3 — Maven+JVM, expected to be the
-   heaviest/flakiest setup of the five, per the design spec).
-2. Investigate the express `setCharset` call-graph gap directly in
+1. Investigate the express `setCharset` call-graph gap directly in
    `parser.rs`'s JS/TS call-site extraction (property-access call through a
    required module's bare identifier vs. a destructured bare-name call to
    the same export) — a candidate root-cause worth its own session, not
-   folded into this benchmark's scope.
+   folded into this benchmark's scope. (Phase 3's Java finding was this same
+   shape of bug — receiver misattribution in `parser.rs` — so it's worth
+   checking whether the `.`-split fix incidentally helps here too before
+   assuming a separate root cause; not verified either way yet.)

benchmarks/b7_task_correctness/run_benchmark.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
-"""B7 -- Task-Correctness benchmark (Phase 1: fd [Rust], flask [Python]).
+"""B7 -- Task-Correctness benchmark (Phase 1: fd [Rust], flask [Python];
+Phase 2: express [JS], zod [TS], gin [Go]; Phase 3: spring-petclinic [Java]).
 
 Measures whether the CALM-scripted refactor workflow (edit_context -> edit at
 each real call site -> diff_impact) completes a real rename task more
@@ -70,7 +71,7 @@
 # needed to worry about for its own read-only use case.
 WORK_ROOT = repo_root_from_here().parent / "calm-b7-work"
 
-SRC_EXTS = {"rust": (".rs",), "python": (".py",), "javascript": (".js",), "typescript": (".ts",), "go": (".go",)}
+SRC_EXTS = {"rust": (".rs",), "python": (".py",), "javascript": (".js",), "typescript": (".ts",), "go": (".go",), "java": (".java",)}
 
 
 def fresh_clone(lang: str, arm: str) -> Path:
@@ -230,7 +231,7 @@ def main() -> int:
         rows.append(row)
 
     summary = {
-        "phase": "B7 Phase 1 (fd/Rust, flask/Python)",
+        "phase": "B7 Phase 1-3 (fd/Rust, flask/Python, express/JS, zod/TS, gin/Go, spring-petclinic/Java)",
         "methodology": "deterministic oracle only (build/test pass + independent "
                         "callsite recall via B12's ground_truth, extension-filtered) "
                         "-- no LLM judge, per design spec constraint",

benchmarks/lib/refactor_tasks.yaml

@@ -153,3 +153,52 @@ tasks:
       - [packages/zod/src/v4/classic/tests/error-utils.test.ts, 544]
     build_cmd: ["pnpm", "install"]
     test_cmd: ["pnpm", "test"]
+
+  # --- Phase 3: spring-petclinic/Java (Maven+JVM) -- deferred to last since
+  # it's the heaviest/flakiest setup per the design spec (§5 sequencing
+  # table): confirmed live this session, Maven Wrapper + ~/.m2 cache were
+  # already warm from an earlier session's language-support benchmarking, so
+  # no network/toolchain install was needed here (unlike Go, which needed a
+  # real sudo-gated toolchain install in Phase 2).
+  - id: rename_petclinic_find_pet_types
+    lang: java
+    corpus: java  # key into b12_tier1_tier2_tool_correctness.corpora.get_corpus()
+    symbol: findPetTypes
+    def_path: src/main/java/org/springframework/samples/petclinic/owner/PetTypeRepository.java
+    def_line: 37
+    new_name: findAllPetTypes
+    # verified live 2026-07-30 against spring-petclinic @ 51045d1648dad955df586150c1a1a6e22ef400c2.
+    # Single interface method (no overload -- ruled out Owner.getPet, which
+    # has 3 overloads, and VetRepository.findAll, which collides with
+    # JpaRepository's own inherited findAll), called from 2 production files
+    # + 3 test files -- same real-usage-plus-test-coverage shape as gin's
+    # cleanPath. NOTE (documented, not a rejected-candidate case unlike
+    # zod's slugify): PetTypeFormatter.java:53 also declares a LOCAL
+    # VARIABLE literally named `findPetTypes` (`Collection<PetType>
+    # findPetTypes = this.types.findPetTypes();`), so the word-bounded
+    # substitution renames that local too. This is benign, not a collision:
+    # Java resolves the method call via `.name()` call-shape independently
+    # of the local var's plain identifier, so renaming both consistently
+    # within the same method body changes no semantics and both arms still
+    # compile -- confirmed by the calm arm's real build/test pass below.
+    oracle_callsites:
+      - [src/main/java/org/springframework/samples/petclinic/owner/PetController.java, 63]
+      - [src/main/java/org/springframework/samples/petclinic/owner/PetTypeFormatter.java, 53]
+      - [src/main/java/org/springframework/samples/petclinic/owner/PetTypeFormatter.java, 54]
+      - [src/test/java/org/springframework/samples/petclinic/owner/PetControllerTests.java, 72]
+      - [src/test/java/org/springframework/samples/petclinic/owner/PetTypeFormatterTests.java, 65]
+      - [src/test/java/org/springframework/samples/petclinic/owner/PetTypeFormatterTests.java, 72]
+      - [src/test/java/org/springframework/samples/petclinic/service/ClinicServiceTests.java, 147]
+      - [src/test/java/org/springframework/samples/petclinic/service/ClinicServiceTests.java, 166]
+    build_cmd: null  # `mvn test` compiles+tests in one step, same shape as Rust's `cargo test`
+    # Excludes the 4 Testcontainers-backed *IntegrationTests classes (Docker
+    # MySQL/Postgres containers) -- verified live: including them pulls a
+    # ~260MB mysql image on a cold cache and pushes a single run past 2
+    # minutes, unnecessary risk against oracle.py's fixed 300s run_cmd
+    # timeout given B7 runs build/test up to 3x per task (baseline + naive +
+    # calm arms). The excluded classes never reference findPetTypes (verified
+    # against the oracle_callsites above), so excluding them costs zero
+    # oracle coverage. `-DfailIfNoTests=false` needed because -Dtest exclusion
+    # patterns alone make surefire treat "0 classes newly excluded to explicit
+    # positive match" as a failure otherwise.
+    test_cmd: ["./mvnw", "-q", "test", "-Dtest=!*IntegrationTests", "-DfailIfNoTests=false"]

crates/calm-core/src/indexer/parser.rs

@@ -1802,11 +1802,36 @@ fn walk_calls(
 /// nested property access used as another call's receiver), "Foo" from a
 /// bare "Foo" scope. Strips a leading `$` (PHP variable sigil) since
 /// tier-2 type_map lookup keys on the plain variable name either way.
+///
+/// Also splits on a plain `.` (not just `->`/`::`) — found live via a real
+/// B7 benchmark run (spring-petclinic/Java, docs/superskills/specs/2026-07-
+/// 30-calm-dfb-levers-design.md Phase 3): Java's `method_invocation` has no
+/// `->` operator, so `this.types.findPetTypes()`'s "object" field text is
+/// the plain-dotted `"this.types"` — before this fix, the missing `.` split
+/// point meant `leading_ident` walked from byte 0 and stopped at the first
+/// `.`, returning `"this"` instead of the real field name `"types"`. Tier-2
+/// then looked up a type for the fake pseudo-variable `"this"`, found
+/// nothing, and dropped the call edge entirely — silently blind to EVERY
+/// `this.field.method()` call in Java, one of the two idiomatic field-access
+/// styles (used specifically to disambiguate a field from a same-named
+/// constructor parameter, e.g. `this.types = types;`) and reproduced on 4 of
+/// 5 real call sites in the corpus's own production+test code. Confirmed
+/// this is genuinely additive, not a behavior change for existing correct
+/// cases: PHP's `$this->helper` already resolved correctly via the `->`
+/// split point (unaffected, no `.` in that text), and Java/PHP/Ruby's
+/// existing single-segment `this`-only tests (`this.logIt()`) have no `.`
+/// after `this` either, so `dot_end` never fires for them.
 fn last_ident_segment(raw: &str) -> Option<String> {
     let raw = raw.trim();
     let arrow_end = raw.rfind("->").map(|i| i + 2);
     let colon_end = raw.rfind("::").map(|i| i + 2);
-    let start = arrow_end.into_iter().chain(colon_end).max().unwrap_or(0);
+    let dot_end = raw.rfind('.').map(|i| i + 1);
+    let start = arrow_end
+        .into_iter()
+        .chain(colon_end)
+        .chain(dot_end)
+        .max()
+        .unwrap_or(0);
     leading_ident(raw[start..].trim_start_matches('$'))
 }
 /// Extract call sites from a source file, each attributed to its enclosing function.
@@ -3278,6 +3303,30 @@ interface Shape {}
         assert_eq!(find(&symbols, "Shape").kind, SymbolKind::Interface);
     }
 
+    #[test]
+    fn test_java_this_qualified_field_call_produces_receiver_not_this() {
+        // Regression for the real bug B7's Phase 3 benchmark run found live
+        // (spring-petclinic/Java, docs/superskills/specs/2026-07-30-calm-
+        // dfb-levers-design.md): `this.field.method()` is one of Java's two
+        // idiomatic field-access styles (used to disambiguate a field from a
+        // same-named constructor parameter, e.g. `this.types = types;`).
+        // Before the `last_ident_segment` fix, the "object" field text
+        // "this.types" had no `.` split point, so `leading_ident` returned
+        // "this" instead of "types" -- tier-2 then looked up a type for the
+        // fake pseudo-variable "this", found nothing, and the call edge was
+        // dropped entirely (reproduced on 4 of 5 real call sites in the
+        // corpus, CALM's own edit_context missing every production caller).
+        let code = "class Repo {\n    java.util.List<String> findAll() { return null; }\n}\nclass Consumer {\n    private final Repo repo;\n    Consumer(Repo repo) { this.repo = repo; }\n    void use() {\n        this.repo.findAll();\n    }\n}\n";
+        let calls = extract_calls(code, "java", "Test.java").unwrap();
+        assert!(
+            calls.iter().any(|c| c.enclosing_name == "use"
+                && c.callee == "findAll"
+                && c.receiver.as_deref() == Some("repo")),
+            "this.field.method() should attribute the field name as receiver, \
+             not the literal string \"this\": {calls:?}"
+        );
+    }
+
     #[test]
     fn test_java_enum_record_constructor_kinds() {
         let code = r#"