fix(bench): B2 oracle covers feature-gated files (--all-features) + coverage audit

Issue #72 (ask #2): a bare `rust-analyzer scip <repo>` compiles only DEFAULT
Cargo features, emitting ZERO occurrences for source files behind non-default
features (bundle.rs/index-bundles, lsp/*.rs/lsp-overlay, http.rs/http). CALM's
tree-sitter indexer parses those unconditionally, so every CALM edge touching
them could never match the oracle — inflating false-positives independent of
resolver quality.

- run_benchmark.py now runs rust-analyzer with --all-features (--ra-features,
  default "all") via a --config-path temp config. "all" not a hand-listed set:
  the gating features live on different workspace members (http on calm-server,
  not calm-core) and a per-name list would error on the crate that lacks it.
- Adds an oracle-coverage audit to the output: oracle_covered_files,
  uncovered_from_files, and precision_on_covered (precision over only
  oracle-visible files) — the honest number the floors should eventually track.

Verified on this repo: bundle.rs / lsp/overlay.rs / lsp/mod.rs go 0 -> present
occurrences under --all-features (http.rs 2 -> 4); all-features .scip is larger,
strictly more coverage.

Threshold re-baseline (ask #3) is DEFERRED to after the std::/core::/alloc::
qualified-path fix (ask #1): per the issue, the remaining non-formal precision
is dominated by BOTH gaps, so resetting floors now would need another reset.
Documented in the B2 README limitations.

Wave 0.2 of docs/plans/2026-08-19-evidence-architecture-execution-plan.md.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: Your Name

benchmarks/b2_call_graph_quality/README.md

@@ -19,6 +19,14 @@ scip-dump` (dùng lại `calm_core::scip::parse`, không viết lại protobuf d
 index` (mặc định feature, tức **chỉ Phase A**, SCIP overlay không bật) rồi so `call_edges` (Rust)
 với oracle.
 
+Oracle chạy với **`--all-features`** (`--ra-features`, mặc định `all`) — xem issue #72: một lần
+`rust-analyzer scip` mặc-định-feature không phát occurrence cho các file sau feature-gate
+(`bundle.rs` sau `index-bundles`, `lsp/*.rs` sau `lsp-overlay`, `http.rs` sau `http`, …), trong khi
+indexer tree-sitter của CALM parse chúng vô điều kiện — làm mọi edge CALM chạm các file đó không bao
+giờ khớp oracle và thổi phồng false-positive. Output giờ báo `oracle_covered_files`,
+`uncovered_from_files` và `precision_on_covered` (precision chỉ tính trên các file oracle thực sự
+thấy) để chỉ số coverage-gap luôn quan sát được.
+
 ## Kết quả đo lần đầu (self-repo, sau Phase A, trước khi bật SCIP overlay)
 
 | | |
@@ -61,3 +69,9 @@ Theo `edge_confidence`:
   dưới thực tế chứ không phải chính xác tuyệt đối.
 - Chưa đo lần chạy có bật SCIP overlay (Phase B) — số trên là baseline Phase A thuần, mốc để đối
   chiếu khi B cải thiện.
+- **Bảng “Kết quả đo lần đầu” và floors trong `scripts/check-b2-thresholds.sh` chưa phản ánh
+  oracle `--all-features` mới.** Việc re-baseline (đo lại honest baseline rồi reset floors) cố tình
+  hoãn đến sau khi fix qualified-path `std::`/`core::`/`alloc::` (issue #72 ask #1) — issue tự ghi:
+  ~967 edge non-ambiguous/non-formal còn lại bị chi phối bởi cả coverage-gap (đã fix ở PR này) *và*
+  qualified-path gap, nên reset floors bây giờ sẽ phải reset lại lần nữa. Đo + set floors một lần
+  sau khi cả hai fix đã land.

benchmarks/b2_call_graph_quality/run_benchmark.py

@@ -150,6 +150,16 @@ def main() -> None:
         default=repo_root_from_here() / "target" / "release" / "calm",
         help="Path to a `calm` binary built with --features scip-overlay",
     )
+    parser.add_argument(
+        "--ra-features",
+        default="all",
+        help=(
+            "Cargo features to activate for the rust-analyzer oracle run. "
+            "Default 'all' (--all-features) so the oracle covers feature-gated "
+            "source files CALM's tree-sitter indexer always parses (issue #72); "
+            "pass a comma-separated list to narrow it."
+        ),
+    )
     args = parser.parse_args()
     repo = args.repo.resolve()
     calm_bin = args.calm_bin.resolve()
@@ -163,8 +173,24 @@ def main() -> None:
 
     with tempfile.TemporaryDirectory() as tmp:
         scip_path = Path(tmp) / "oracle.scip"
-        print(f"Running rust-analyzer scip on {repo} ...")
-        run([ra_bin, "scip", str(repo), "--output", str(scip_path)])
+        # Oracle coverage fix (issue #72): a bare `rust-analyzer scip <repo>`
+        # compiles only DEFAULT Cargo features, so it emits ZERO occurrences
+        # for source files gated behind non-default features (bundle.rs behind
+        # `index-bundles`, lsp/*.rs behind `lsp-overlay`, http.rs behind
+        # `http`, ...). CALM's tree-sitter indexer parses those files
+        # UNCONDITIONALLY, so any CALM edge touching them could never match the
+        # oracle -- inflating the false-positive count independently of
+        # resolver quality. Activating all features aligns the oracle's file
+        # coverage with CALM's. `"all"` (not a hand-listed set) because the
+        # gating features live on different workspace members (`http` on
+        # calm-server, not calm-core) and a per-name feature list would error
+        # on the crate that lacks it; --all-features cannot.
+        feats = "all" if args.ra_features == "all" else args.ra_features.split(",")
+        ra_config = Path(tmp) / "ra-config.json"
+        ra_config.write_text(json.dumps({"cargo": {"features": feats}}))
+        print(f"Running rust-analyzer scip on {repo} (features={args.ra_features!r}) ...")
+        run([ra_bin, "scip", str(repo), "--output", str(scip_path),
+             "--config-path", str(ra_config)])
 
         dump = run([str(calm_bin), "scip-dump", str(scip_path)])
         occurrences = [json.loads(line) for line in dump.stdout.splitlines() if line.strip()]
@@ -184,6 +210,22 @@ def main() -> None:
     oracle_hit = {(e[0], e[1], e[2], e[3]) for e in matched}
     recall = len(oracle_hit) / len(oracle) if oracle else 0.0
 
+    # Oracle coverage audit (issue #72): a file the oracle never emitted an
+    # occurrence for (still feature-gated even under --all-features, generated,
+    # or otherwise excluded) can't corroborate ANY CALM edge originating in it,
+    # so those edges depress precision for reasons unrelated to resolver
+    # quality. Report coverage explicitly, plus a `precision_on_covered` that
+    # scores only edges whose from-file the oracle can actually see -- the
+    # honest number check-b2-thresholds.sh's floors should eventually track.
+    oracle_files = {o["file"] for o in occurrences}
+    calm_from_files = {e[0] for e in calm_edges}
+    uncovered_from_files = sorted(f for f in calm_from_files if f not in oracle_files)
+    covered_edges = [e for e in calm_edges if e[0] in oracle_files]
+    covered_matched = [e for e in covered_edges if (e[0], e[1], e[2], e[3]) in oracle]
+    precision_on_covered = (
+        len(covered_matched) / len(covered_edges) if covered_edges else 0.0
+    )
+
     by_conf: dict[str, list[tuple]] = defaultdict(list)
     for e in calm_edges:
         by_conf[e[4]].append(e)
@@ -203,13 +245,34 @@ def main() -> None:
     for conf, stats in conf_precision.items():
         print(f"{conf:<12} {stats['count']:>8} {stats['precision']:>10.3f}")
 
+    print()
+    print(
+        f"Oracle file coverage: {len(oracle_files)} file(s) with >=1 occurrence; "
+        f"{len(uncovered_from_files)}/{len(calm_from_files)} CALM from-file(s) "
+        f"invisible to the oracle"
+    )
+    print(
+        f"Precision on oracle-covered files only: {precision_on_covered:.3f}  "
+        f"({len(covered_matched)}/{len(covered_edges)})"
+    )
+    if uncovered_from_files:
+        preview = ", ".join(uncovered_from_files[:8])
+        print(
+            f"  uncovered from-files (first 8): {preview}"
+            f"{', ...' if len(uncovered_from_files) > 8 else ''}"
+        )
+
     result = {
         "repo": str(repo),
         "oracle_edges": len(oracle),
         "calm_edges": len(calm_edges),
         "precision": precision,
         "recall": recall,
         "by_confidence": conf_precision,
+        "oracle_covered_files": len(oracle_files),
+        "calm_from_files": len(calm_from_files),
+        "uncovered_from_files": len(uncovered_from_files),
+        "precision_on_covered": precision_on_covered,
     }
     out_path = Path(__file__).parent / "results.json"
     out_path.write_text(json.dumps(result, indent=2))