Fix hub analysis and bounded trails; audit graph comparison evidence

[forhappy]

Summary

• Fix five hub-analysis defects: library-like declaration names, unstable ties, isolated candidates, explicit kinds overridden by labels, and extensionless source files.
• Fix typed node trails losing feasible paths under a hop bound and readmitting budget-rejected nodes.
• Fix the same feasible-prefix defect in the separate undirected path command. Bound adjacency work and cumulative path keys; work exhaustion is a nonzero error, never a no-path claim.
• Fix Rust receiver shadowing across lets, loops, closures, match guards, conditional lets, and destructuring. Preserve initializer/else scope and invalidate older AST caches.
• Preserve natural-query operands in agent answers and share symbol normalization with typed resolution. Fix wrong subjects, node bases, and follow-up operands.
• Repair comparison scoring/provenance and document oracle mistakes, source-excerpt differences, ambiguity policies, and competitor advantages.
• Wire hub/path regressions, an independent exhaustive oracle, and comparison-scorer tests into CI.

Evidence and limits

The release comparison at 8a13928 passes 50/50 Compass vs 44/50 Graphify development text oracles. Five extra passes concern source-excerpt availability; one concerns Axum file lookup. Both tools pass all five source-grounded positive navigation witnesses. Graphify uses fewer estimated tokens on the 44 shared passing rows. These results do not establish broad superiority or held-out accuracy.

That release checkpoint precedes the extensionless-source and legacy-path fixes. The final query binary separately passes all 50 questions and five path witnesses on explicitly retained, hash-verified graphs. This is query regression evidence, not a new extraction or performance comparison.

The independent oracle checks 729 four-node graphs at three hop bounds in both path engines (4,374 queries), including unreachable outcomes, optimal costs/hops, and actual edge chains/directions. It failed before the legacy-path fix and passes afterward. Synthetic boundary probes separately record Graphify's ambiguity warning plus endpoint selection, and Compass's explicit refusal; these are not folded into a broad accuracy score.

Separate source-first fd evaluation

The 12 questions and 10 positive call pairs (16 occurrences), plus two negative pairs, were committed before the first extraction/query run on pinned sharkdp/fd. Compass passes 11/12 text oracles and Graphify 9/12. Both preserve all 10 reviewed pairs; Compass preserves 16/16 call sites and Graphify 10/16. Graphify wins one callees question and uses fewer estimated tokens on the eight shared passes (88 vs 227).

The missing Compass loop calls are real. A reduction also exposed a precision defect: loop and untyped local shadowing inherited an outer parameter's receiver type. The receiver-shadowing precision defect now has a native fix and negative regressions; the fd loop-inference recall gap remains open. A separate post-output audit identifies Graphify linking CommandBuilder::new to CommandTemplate::new; the original text pass remains recorded. Two additional source-grounded path witnesses pass for both tools. This selected sample is not representative accuracy or performance evidence.

Receiver correction verification

The shadowing regression failed before the change. Current checks pass 27 Rust language tests, all 206 universal resolver integration tests, 33 filesystem contracts, workspace and changed integration-test Clippy, and the full native baseline (1,083 passed, 0 failed, 2 ignored). Full fixture qualification and fresh executable replay passed, including independent Markdown and React checks. The fd outcomes and reviewed call occurrences are preserved. The default parser-source bundle path was missing; the gate is using an existing checkout-local bundle whose language-definition hash matches the vendored manifest.

Compatibility

AST cache semantics advance from 2 to 3; older AST facts rebuild automatically across languages. Evidence/graph schemas and advertised producer capabilities remain unchanged. Existing graphs require re-extraction to receive receiver corrections; historical realizations remain immutable.

Corrected hub candidates and path results can differ. Each legacy path ranking pass now permits 1,000,000 adjacency entries and 16 MiB of cumulative path-key bytes. Exceeding a limit fails explicitly; unusually expensive requests may need a smaller depth or graph. Compatibility and migration notes are included. No release version or tag is changed.

Verification

• Workspace native tests: 1,083 passed, 0 failed, 2 ignored.
• Workspace Clippy, plus dedicated query integration-test Clippy: passed with warnings denied.
• Hub integration: 12 passed; traversal: 11; legacy query coverage: 6; exhaustive oracle: 1 (4,374 queries).
• CLI query/product suites: 35 + 9 passed, including work-limit exit/stream behavior.
• Benchmark Python tests: 49 passed.
• Query relevance qualification: 5 passed at the earlier checkpoint; its 500 cases are synthetic phrasing variants, not independent repository judgments.
• Full fixture qualification passed after the seventh correction, including Markdown and independent React source checks. Its release binary predates the eighth path fix; the latest query change is covered by the checks above.
• Formatting, diff checks, and product boundary: passed.

The full platform/packaging/browser matrix is delegated to CI. See docs/implementation/code-graph-intelligence-audit-2026-09-26.md for the acceptance matrix, retained evidence, and remaining work.

Natural-language comparison and corrections

The preregistered ten-question, five-language ask comparison initially scored Compass 9/10 and Graphify 10/10 on selected-fact text recall. Source review additionally found seven wrong Compass headline subjects, despite text passes. Two corrections preserve parsed CLI operands and reuse typed-query symbol normalization in the renderer. Both have failed-before native regressions.

The final query-only replay on digest-checked retained graphs scores 10/10 for both tools; a separate source-grounded diagnostic confirms all ten Compass headline subjects and node bases. Original and intermediate results remain recorded. On these ten shared text passes, median output is 279.5 versus 1,439.5 estimated tokens. Graphify discloses four overruns of the requested 2,000-token budget. Text recall, subject correctness, full-answer precision, and budget compliance are distinct measures.

Final verification: 1,145 native tests passed (1,083 lib/bin + 36 CLI query + 9 product + 17 output), two ignored. Workspace and changed integration-target Clippy passed; an existing expect_err in the touched output test was replaced with error propagation. The output suite was rerun afterward. Formatting, product boundary, diff checks, and 49 benchmark tests pass.

Shared MCP comparison and corrections

Preregistered 29 questions per tool across Cobra, Flask, Gson, Zod, and Axum, using the same stored graphs and public MCP operations. All 58 requests completed in each run. An isolated Graphify 0.9.67 MCP environment preserves all 227 compared package files and records optional SDK dependencies. Full community enumeration uses Graphify's explicit 262,144-token allowance; this is not an equal 2,000-token comparison.

The first run exposed Compass dropping labeled community IDs in its traversal cache and silently choosing the first ambiguous neighbor. Native regressions failed before both fixes. Cache magic advances from TRAILT04 to TRAILT05 to rebuild deficient projections. MCP now returns stable ambiguity candidates with source paths and exact IDs. Original graphs and historical artifacts are unchanged.

Graph-consistency check	Initial Compass	Corrected Compass	Graphify
Node/edge/community totals	0/5	5/5	5/5
Largest community members/count	0/5	5/5	5/5
Missing community	5/5	5/5	5/5
Filtered neighbor displayed triples	5/5	5/5	5/5
Ambiguous neighbor lookup	0/4	4/4	4/4

The first two rows share one cache defect. The independent auditor verifies graph/input/collector hashes and raw JSON-RPC transcripts. These are graph-consistency checks, not full source precision or functional clustering judgments.

A separate post-output Flask source diagnostic exposed relation filtering after neighbor grouping: a preceding containment edge hid a real call in both directions. Filtering now precedes grouping. The retained source and graph reproduce empty answers before the fix and the correct call afterward. Native coverage tests both directions, reversed edge order, and duplicate calls. The original five neighbor questions did not detect this bug; their scores are preserved.

Final replay mcp-paired-03 completes all 58 requests and preserves the corrected table. Only 29/50 Compass and 37/50 Graphify hub labels uniquely identify a graph node. Every identifiable entry's degree matches independent computation; ambiguous entries remain unverified. Complete ranking eligibility and source-reviewed god-object judgments remain open. Graphify's separate CLI JSON supplies IDs, so this is specifically an MCP presentation finding.

Latest verification: 1,149 native tests passed, zero failed, two ignored; workspace Clippy with warnings denied, formatting, diff checks, and product boundary pass. The benchmark suite passes 65 Python tests. The extraction fixture gate remains the prior receiver checkpoint; the MCP corrections are verified on retained graphs and native regressions.

The broader superiority objective remains unproven. Open work includes fd receiver-inference recall, reliable hub navigation, source-reviewed community responsibilities, additional path/ambiguity/bound cases, and held-out evaluation.

Hub identity and direct navigation

MCP hub responses now include exact IDs and source anchors in both text and the versioned compass.mcp.hubs/1 structured result. Degree, eligibility, and ranking remain unchanged. The description explicitly treats connectivity as a topology observation. Text escapes IDs safely; exact lookup precedes whitespace normalization, preserving unusual legacy IDs. Native regressions cover duplicate names, exact-ID round trips, source fields, and actual MCP structured transport.

The repeated 58-RPC comparison preserves every prior graph-consistency result. All 50 Compass hub identities, degrees, and source anchors match its stored graphs; Graphify's label-only MCP responses identify 37/50 uniquely. Its CLI JSON supports IDs, so this is specifically an MCP finding.

A separately committed diagnostic gives each hub exactly one neighbor follow-up, using only its returned ID or label. All 100 requests execute in both before/after runs. Compass completes 4/50 direct navigations before the change and 50/50 afterward; Graphify completes 28/50 in both runs. Success checks seed identity, headline, and displayed adjacency against the tool's own stored graph. This excludes additional disambiguation steps and alternative CLI workflows and does not establish source precision or design quality.

Corrected Compass emits 593,962 text bytes / 626,338 wire-response bytes for five hub responses plus 50 follow-ups, versus 265,393 / 272,996 for Graphify. Completion counts and returned hub sets differ; these totals do not establish an efficiency win. All 200 follow-up transcripts were checked against recorded requests, responses, text, and byte counts.

Separate post-output source diagnostics show a containment-dominated Compass Zod test-module hub and two wrong Graphify Axum generic-reference targets. Exact source/graph witnesses are retained; these are not representative accuracy rates or original-suite scores.

Latest verification: 1,198 native tests passed, zero failed, two ignored; workspace and coverage_paths Clippy passed; 72 Python benchmark tests passed; formatting, diff checks, and product boundary passed. Full extraction qualification remains the receiver checkpoint. Source-reviewed community/design quality, broader path cases, held-out evaluation, and the fd receiver-inference recall gap remain open.

Bounded MCP paths and fair input-mode comparison

The path diagnostic adds 28 questions per tool across the same five languages: forward/reverse navigation, hop limits, missing/ambiguous endpoints, and disconnected pairs. All 56 requests execute. The first capture preceded its intended registration commit after a preliminary runner test failed; its archived preregistration claim is explicitly corrected to development evidence. Original artifacts are retained.

A separate label-input arm uses the same positive endpoints and bounds with each tool's display labels (30 RPCs). Graphify's public tool advertises labels/keywords. Graphify wins the baseline label comparison, 10/10 verifiable paths versus Compass 8/10; both pass 5/5 hop-limit cases. The ID diagnostic's Graphify endpoint-substitution failures are not generalized to its label interface.

Compass now requires unique exact path endpoints, reports ambiguity candidates, explores within 0–64 hops and shared work/allocation budgets, and prefers structural relations among equal-hop paths. Versioned structured results preserve node IDs/source anchors and the selected edge IDs/directions. Native regressions cover limits, ambiguity, parallel edge identity, and source lines. Two intermediate replays caught missing source lines and edge IDs in compact-cache projection; both failures remain documented. Path selection and rendering now use one full bounded snapshot.

Final label results tie: Compass 10/10 and Graphify 10/10, both 5/5 explicit hop bounds and all five reviewed source routes. On exact-ID diagnostics, Compass improves 8/10→10/10 paths and 0/4→4/4 ambiguity refusal; Graphify remains 0/10 and 0/4. Missing endpoints are 5/5 versus 0/5. Global disconnection completion falls from Compass 4/4 to 2/4 because the corrected bounded search stops at eight hops for Gson/Axum; those are explicitly incomplete, not credited as disconnections. Graphify completes 1/4 in this ID arm. No broad superiority or directed-call-flow claim follows.

The current independent auditor rechecks all 86 original baseline outcomes unchanged, validates final raw transcripts, and verifies node anchors plus selected edge identities. Final binary SHA256: b16d7f755a81bf68110737a445701158ee541a4cc0f070b9e4e800cff693c988. Full source patch/provenance and all before/intermediate/after captures are retained in the evaluation workspace.

Latest checks: 1,212 native passed, zero failed, two ignored; 86 Python passed; Clippy with warnings denied, formatting, diff checks, and product boundary passed. Native verification includes 6,561 tiny-graph queries across three path engines and independent exhaustive oracles. Full extraction qualification remains the prior receiver checkpoint; concurrent debug captures do not establish performance. Compatibility/migration docs describe exact endpoint inputs, 0–64 limits, structured statuses, and changed equal-hop ties.

The objective remains open: source-reviewed god-object/community quality, broader directed paths and walks, representative source precision/occurrence recall, fd inference recall, and held-out confirmation still need evidence.

Hub explanations and source-role census

Reviewed the original 100 MCP hub entries against pinned source. Fifty Compass identities and 37 uniquely displayed Graphify identities have exact reviewed anchors/excerpts; 13 Graphify entries remain unidentified. These are post-output role descriptions on different returned sets, not comparative design-quality or precision scores. All ten Compass Zod hubs are whole-file modules, four covering tests. The census also separates production types/callables, test helpers, examples, and implementation blocks. No source-role judgment is inferred from degree alone.

Compass hub output now adds node kind and bounded per-relation incoming/outgoing/undirected record counts. Analysis belongs to compass-graph, with additive compass.hub-connectivity/1 structured data and text. Parallel records, self-loops, missing endpoints, stable ordering, and omitted categories are explicit. Eligibility, ranking, and degree remain unchanged; undirected ranking metadata is corrected. Counts describe the stored graph, not independently verified source occurrences or god-object defects.

The repeated five-language MCP comparison completes 58/58 RPCs, preserves all prior graph-consistency and hub-ranking records, and verifies 50/50 Compass summaries plus their text blocks against independent graph counts. Graphify's direct hub response lacks this summary; it is unavailable, not scored as an incorrect explanation. Other neighbor/CLI workflows remain outside this diagnostic.

For the same five Compass hub responses, text grows 9,136→26,620 bytes and actual response-wire size grows 24,146→75,299 bytes. Graphify remains 1,489 text / 1,989 wire bytes. This additional evidence has a payload cost; no efficiency or broad superiority claim follows. Example: Axum route() has 306 incoming call records and one outgoing call, while Zod's to-json-schema.test hub is dominated by containment.

Final frozen binary SHA256: 5382b51b86ab76032173a17e638a3ad525600ec1726364d3244edddb7abd2c19. Latest checks: 1,162 native passed, zero failed, two ignored; 93 Python passed; Clippy, formatting, diff checks, and product boundary passed. Native selection includes the full lib/bin baseline and analyze_coverage, coverage_paths, compass_product (different integration selection from the prior path checkpoint). Full extraction qualification remains the earlier receiver checkpoint. All source reviews, request/response checks, before/after payload counts, and development failures are retained in the audit report/artifact workspace.

Source-based god-object/design judgments, community cohesion, directed paths/walks, fd recall, and held-out task confirmation remain open.

Frozen five-language confirmation panel A

Registered 55 questions, 21 selected edge pairs, and ten source-path witnesses before executing new pinned Chi/Click/jsoup/Redux/WalkDir checkouts. All ten builds and 110 requests completed. Original text recall is tied at 46/55; independent source-path audit is Compass 6/10 versus Graphify 8/10. Graphify leads broad retrieval; Compass leads file-path retrieval and ambiguity handling. Four Compass text passes are unresolved candidate lists, and two Graphify path text passes select same-named test functions. These are not correctness wins. The full report records category results, costs, and provenance limits.

Preserved an oracle mistake and its separate correction: the registered Click witness omitted a real second call at _compat.py:450. Corrected selected-pair relationship/absence results remain Compass 15/21 versus Graphify 20/21; occurrence agreement is 15/21 versus 17/21. Four Compass rows cannot establish unique Redux export/function identity under the registered rule; they are not four proven missing calls. Graphify loses repeated occurrences, and both miss a jsoup chained call. These selected witnesses do not measure whole-graph precision.

Post-output exact-ID/display-label path diagnostics are reported separately. They use source-prepared inputs, do not measure retrieval cost, and do not replace the frozen results. Graphify path help does not promise exact-ID semantics.

Ambiguity correction after confirmation

Typed ambiguous answers now request exact IDs and use the operation as their answer basis, without naming one fallback subject or claiming no path. Every retained ambiguity candidate carries its ID in text. All 55 Compass questions were replayed against the original graphs: text scores remain 46/55; four inspected real-repository ambiguity responses have corrected headlines and IDs. This is development regression evidence, not an improved held-out score.

Verification: 1,155 native tests passed, zero failed, two ignored (workspace lib/bin plus agent_query, code_query_cli, compass_product); 95 Python tests passed; workspace/selected-integration Clippy, formatting, diff, and product-boundary checks passed. Extraction/viewer gates were not rerun for this presentation-only change. Broad superiority, source precision, functional community quality, god-object judgment, and directed/long paths remain unproven.

Go receiver correction and full relationship-delta review

Recovered source-proven Go receiver types from control initializers while respecting nearer lexical bindings, closure parameters, ranges, callback factories, and shadowed package names. Type-switch case narrowing remains unsupported. AST cache semantics advance from 3 to 4; rebuild existing Go graphs. Published history remains immutable.

Fresh paired Chi/Cobra development runs use the same pinned source and unchanged questions. Text scores remain Chi 11/11 versus 10/11 and Cobra 10/10 versus 9/10 (Compass versus Graphify). All 42 final requests complete. No text-score or latency improvement is claimed.

The complete relationship delta on Chi contains exactly two source-reviewed new calls and no removals. The original four pair/occurrence witnesses now match both tools (Compass previously 3/4). A separate post-output compression-interface witness matches Compass and is missing in Graphify; it is not an independent held-out score or a runtime dispatch proof.

Complete-delta review caught four spurious Cobra references in the intermediate binary. A native test reproduced the issue. Returned callback invocations now retain only the supported inner factory call. The final Cobra graph has no relationship delta from its baseline; the faulty intermediate output and all source judgments remain recorded.

Final binary SHA256: bb09a5335c80fd7dd710e008b4a2f30f9403108e4883ed74e7d7c0de1b0aaca9. Verification: 1,410 native passed, zero failed, two ignored; workspace/selected-integration Clippy and 95 Python tests pass; formatting, diff, and product-boundary checks pass. The Go correction’s full fixture qualification passed. The subsequent route-hierarchy correction failed its full fixture run; see the source-reviewed follow-up below. Broad superiority, source precision, community/design quality, and directed/long paths remain unproven.

Panel A MCP extension and source-backed hub correction

Registered 60 new MCP requests before execution on the frozen panel graphs, after the original CLI outputs were observed. Both tools match stored counts, largest-community membership, missing-community behavior, and selected neighbor label/direction triples on all five repositories. Compass preserves all five ambiguities; Graphify silently selects one Chi declaration. Direct MCP hub identities are verifiable for 50/50 Compass versus 41/50 Graphify entries; Graphify CLI JSON can provide IDs, so this is specifically a display finding. All 50 Compass connectivity summaries match the graphs. Different partitions and returned sets do not establish cohesion or god-object quality.

The complete source-role census exposed a Compass defect: a test-local Chi route ranked second because generic filesystem rules gave it 68 outgoing containment records (degree 59) across independent routers. A real-source negative failed on both original and Go-corrected graphs. A native regression reproduced it. Route-parent inference now requires recognized filesystem-convention evidence; programmatic mounts/groups remain in their owning framework composition rules. Framework semantics advance to 7 and build-state seals include that version.

Fresh paired builds and all 110 original CLI requests across five languages show exactly 88 removed Chi containment records, no added relationships versus the Go-corrected baseline, and no relationship changes in the other four repositories. The recorded negative now passes; Graphify lacks comparable route endpoints and receives no absence credit. Text scores stay 46/55 each and source-path matches stay Compass 6/10 versus Graphify 8/10. Corrected selected-pair relationships are 16/21 versus 20/21, occurrence agreement 16/21 versus 17/21; Compass's one-pair improvement comes from the earlier Go fix.

The repeated 60-request MCP run preserves consistency/ambiguity results. The two inflated Chi route hubs disappear, replaced by a reviewed production type and test helper. Other hub rankings are unchanged. Complete before/after role censuses, unknown identities, costs, source excerpts, graph deltas, and all failures are preserved. Full response text remains larger for Compass; no latency or efficiency superiority is claimed.

Verification: 1,431 native tests passed, zero failed, two ignored; all 17 framework-route tests pass; 97 Python tests pass. Expanded Clippy passes after replacing an existing expect_err in a qualification test with an explicit error assertion and rerunning its four tests. Formatting, diff, and product-boundary checks pass. The new full fixture qualification failed at the topology floor; the follow-up below identifies a remaining semantic defect. Broader filesystem-convention correctness, functional cohesion, god-object judgments, directed/long paths, and overall superiority remain unproven.

Historical fixture audit: remaining defect identified

The route-hierarchy fixture run completed its native scale checks, deterministic rebuild comparisons, and existing semantic assertions, then failed at 1,270 edges against a floor of 1,284. It did not reach Markdown or React qualification.

A fresh comparison of frozen binaries on the identical fixture corpus isolates 19 removed false containment records, zero additions, and unchanged node identities/content except community assignments. Source review covers every removed link across Drupal, Express, Flask, FastAPI, Vue Router, Spring, and frontend route modules. The checked-in review preserves graph/binary/source hashes, all removed identities, and each policy change. Count bounds are adjusted by exactly the observed delta, retaining their previous margins.

Manifest version 3 adds eight source-reviewed independent-route assertions that require route nodes on both sides and forbid directed containment at any confidence. The old graph fails all eight. The corrected production graph passes seven and still fails one: a filesystem-derived React Router /tanstack route is made a parent of sibling /home. The remaining resolver and frontend source oracle both select the first nearby route module, so their agreement is not independent semantic proof. The semantic qualification gate intentionally remains failing until this production defect is corrected. No complete qualification pass is claimed.

Verification: 87 script tests (including 23 oracle tests) and 97 benchmark tests pass; formatting, diff, and product-boundary checks pass. A synthetic checker mutation exercise rejects each of 20 false-edge restorations; it is not a production repair. No Rust production code changed in this follow-up. A separately retained native regression reproduces the Java constructor-receiver gap; no Java fix or score gain is claimed.

The following checkpoint replaces that parent rule; the earlier failure is retained as audit history.

Current checkpoint: framework-specific route parents

Commit c20db15 replaces directory-order lookup with framework parent roles and preserves nearest-parent ambiguity. Framework semantics advance to 8; the product remains 0.3.30. The independent JavaScript oracle uses pairwise convention checks, with 15 manually specified cases. Native coverage adds a 23-case forward/reverse matrix. Historical Next, React Router, and TanStack hierarchy scorecards are explicitly invalidated until their sources are re-reviewed.

On identical original fixture sources, the new binary removes exactly 12 additional false containment records, adds none, and retains all 1,276 nodes except community assignments. All 18 source-reviewed negative groups pass; individually restoring each false edge fails. Two separately measured Next layout fixtures supply four exact positive pairs; missing or duplicate hierarchy records fail. Count bounds retain their prior margins, with every delta recorded in the checked-in fixture review.

A pinned read-only projection of shadcn/ui (273 files, commit a87a63b2ca25143d26c8bd0903e4e9bc77b3f824) improves from 6/7 to 7/7 on source-selected pairs recorded before graph inspection. Complete edge review finds 13 false links removed and four correct nested-layout links added; nodes and common edges remain unchanged except communities. This is development evidence over a partial repository, not held-out or graph-wide precision.

Fresh paired builds and the unchanged 110 CLI requests across Go, Python, Java, TypeScript, and Rust preserve the prior scores: text 46/55 each; source-checked paths Compass 6/10 vs Graphify 8/10; selected relationships 16/21 vs 20/21; complete reviewed occurrences 16/21 vs 17/21 with the corrected Click oracle. The five Compass graphs are byte-identical to the preceding checkpoint. No overall quality, speed, or god-object superiority is claimed.

Verification: 1,436 native tests passed, two ignored; final production build and workspace/selected-integration Clippy passed. The broader Clippy invocation exposed 39 existing unwrap/expect violations in the untouched react_frontend test. All 88 script tests, 15 JavaScript oracle cases, 97 benchmark tests, formatting, diff, product-boundary, and standalone positive/negative frontend checks pass. The first full fixture invocation stopped at an absent default parser bundle. The second uses the existing per-worktree bundle and completed successfully, including semantic/topology/Markdown assertions, native scale checks, deterministic lifecycle checks, and release frontend qualification. This pass qualifies production commit c20db15; the historical pinned hierarchy scorecards remain invalidated pending source re-review.

Next: re-review invalidated pinned hierarchy evidence and address the source-proven Java/TypeScript/Rust navigation misses. Functional cohesion, god-object diagnosis, long/directed paths, and overall superiority remain unproven.

Java constructor receiver checkpoint

Commit 22814e5 derives named constructor receivers from syntax, preserves overload/occurrence evidence, and stops inventing external types from arbitrary expressions. Enclosing-instance creation retains unresolved ownership instead of selecting a same-named import. AST cache semantics advance to 5; product remains 0.3.30 and schemas/capabilities are unchanged.

The native regression covers direct/qualified/parenthesized construction, overloads, repeated occurrences, value/type namespaces, anonymous/enclosing/cast/array/chained uncertainty, provenance, and input-order determinism. A javac/javap diagnostic independently corroborates target distinctions; classes were not executed. The depth-limited real call is explicitly unresolved, not an absence success. On identical diagnostic sources, nine correct calls are added, three false relationships and two invented nodes disappear, and cache upgrade equals a clean rebuild.

Fresh paired builds and the unchanged 110 requests on the five-language development panel give text 46/55 each, source paths Compass 6/10 versus Graphify 8/10, selected relationships 17/21 versus 20/21, and complete reviewed occurrences 17/21 each. Compass newly recovers Jsoup.isValid to Cleaner.isValidBodyHtml. All 122 added jsoup call occurrences (10 production, 112 test) were reviewed against receiver/import context, declarations, overloads, source anchors and direction. Four other Compass graphs are byte-identical. This is development evidence, not fresh held-out or representative precision; no speed or overall superiority claim follows.

Verification: 1,439 native tests passed, zero failed, two ignored. After a test-only redundant-error-wrapping correction, workspace and selected-integration Clippy and the focused regression pass. Formatting, diff and product-boundary checks pass. The fixed fixture graph delta is zero, with no topology threshold changes. Full fixture qualification for Java production commit 22814e5 completed with exit 0, including scale, semantic/topology, lifecycle determinism, Markdown, and release frontend checks. The release executable and log hashes are retained in the development review.

See benchmarks/agent_query/java_constructor_development_review.json for complete delta identities, source/artifact hashes, and limits. Existing incomplete Java varargs display signatures, Redux export/function ambiguity, fd inference gaps, god-object responsibilities, community cohesion, directed/long paths and general superiority remain open.

Export binding query checkpoint

Commit 9b63873 resolves ordinary names to their declarations only when complete exact, nondeferred export occurrence evidence proves the relationship. Exact export IDs remain usable; genuine ambiguity and bounded proof exhaustion remain explicit. The traversal projection now retains the weakest evidence confidence and deferred state, rebuilding disposable TRAILT05 caches as TRAILT06. Product version, published graph records, schemas, and AST cache semantics are unchanged.

Fresh paired builds and all 110 unchanged requests on the five-language development panel yield text-oracle scores Compass 49/55 versus Graphify 46/55, and source-checked paths 8/10 each. The three newly completed queries are Redux callees and both directions of the undirected miniKindOf/ctorName path. Every graph file for both tools is byte-identical to the Java checkpoint. This is query-resolution progress, with no extraction gain claimed.

The original relationship identity oracle remains Compass 17/21 versus Graphify 20/21; complete reviewed occurrences remain 17/21 each using the separately disclosed corrected Click witness. Four Redux identity failures and both tools' WalkDir path failures are retained. Reusing this panel is development evidence, not held-out confirmation or general superiority.

Verification: 1,180 native tests passed, zero failed, two ignored across workspace lib/bin and selected export/cache/traversal/store/CLI/product integrations. Workspace and selected integration Clippy, formatting, diff and product boundary pass. Frozen source hashes match the measured executable. Full fixture qualification passed for query/cache production commit 9b63873, including native scale, semantic/topology, lifecycle determinism, Markdown, release build, and frontend precedence/positive/negative/source-anchor checks. The release executable and complete log hashes are retained. See benchmarks/agent_query/export_binding_development_review.json for provenance and limits.

Source-reviewed directed two-to-four-call path questions across five languages are now registered before their first execution. God-object responsibility, functional community cohesion, representative precision, long/directed navigation quality, and general superiority remain open.

Directed call-path development results

Five source-reviewed two-to-four-call chains across the same five languages were committed as bc4374a before execution. Both tools received identical short endpoint names and hash-verified stored graphs. All 20 forward/reverse requests completed without process failures, timeouts or capture exhaustion.

Source-supported forward call paths are 2/5 per tool: Compass completes Click and WalkDir, while Graphify completes Click and Redux. Compass retains genuine Chi, jsoup and Redux endpoint ambiguity; those refusals do not complete the positive requests. Graphify's Chi and WalkDir routes mix references and method-membership edges, and jsoup reports no route. No directed-navigation lead is established.

Compass's Click route uses the valid second call occurrence at line 188 instead of the frozen witness at line 181. The explicit source adjudication is retained separately: literal frozen-site agreement is Compass 1/5 versus Graphify 2/5, source-supported chains 2/5 each. No reverse paths are returned and no global unreachability credit is awarded. These are selected development queries on reused graphs, not held-out confirmation or timing evidence.

See benchmarks/agent_query/directed_path_development_review.json for identities, exact source spans, raw-artifact hashes, oracle correction and all failures. God-object responsibilities, functional community quality, representative precision and overall superiority remain unproven.

Benchmark continuation correction

The harness previously sent the literal terminal marker none as a cursor. It now follows only one pagination footer with a real, previously unseen token and ignores source/prose next= text. Regression coverage includes LF/CRLF, valid cursor forms, terminal/repeated tokens and conflicting footers; 99 benchmark tests pass.

A successful query-only replay of all 110 unchanged requests preserves executable and graph digests, source pins, and each source working directory. Scores stay Compass 49/55 versus Graphify 46/55. Only the invalid Redux follow-up disappears; its missing miniKindOf answer remains a product retrieval failure. All Compass pages are byte-identical. Three Graphify query outputs vary within their output budgets while scores and byte counts remain unchanged; no content-equivalence or causal claim is made.

The first replay used the wrong working directory and lost eight source excerpts. It is explicitly invalidated and retained, including a later summary-generation error. The successful second replay and exact runner/raw-artifact hashes are in benchmarks/agent_query/cursor_harness_correction_review.json. No production cache failure or score gain is inferred from the invalid attempt.

A separate Redux diagnosis confirms that the original broad question reads 431 candidates in 73 probes but admits no seeds; shorter phrase/name queries retrieve source-backed candidates. Those post-output diagnostics do not replace the failed question. Retrieval/specificity, god-object responsibilities, community cohesion and overall superiority remain open.

Help limit correction and next Java defect

Discovery help now preserves the 10,000 examined-relationship default separately from the 128 returned-edge default. A failed-before regression exposed numeric-prefix replacement of 10000 when adjusting 1000. Both help entry points now agree with runtime defaults. Runtime behavior, schemas and release version are unchanged.

Verification: 1,107 native tests passed, zero failed, two ignored (workspace lib/bin plus help/product integrations); workspace and help integration Clippy passed with warnings denied. Formatting, diff and product boundary pass. Full fixture qualification passed for preceding query/cache commit 9b63873; it was not repeated for this help-only correction.

A compiler-valid Java varargs reduction now demonstrates a remaining correctness gap. javac/javap support five expected signatures and five call targets; Compass preserves only two correct signatures and two calls, missing string, integer and explicit-array varargs overload calls. The fixture, compiler evidence and exact graph identities are retained in benchmarks/agent_query/java_varargs_diagnostic_review.json. This historical baseline is preserved; the correction and repeated comparison follow below.

Java varargs and array evidence correction

Java spread parameters now retain their declared signatures, canonical array types, value types and type references. Explicit array arguments preserve rank. Overload selection uses strict fixed arity, loose fixed arity, then varargs expansion; incomplete evidence and incomparable targets preserve ambiguity. The exact-match shortcut requires a complete parameter-type vector, including for zero-argument calls. AST cache semantics advance to 6; the product remains 0.3.30.

The compiler-checked development reduction covers 25 explicit internal method-call occurrences: correct targets improve from 6 to 24, wrong targets fall from 5 to 0, and missing occurrences fall from 14 to 1. The remaining method-result type gap is retained as missing recall. External and compiler-inserted calls are outside this selected oracle. Classes were compiled/disassembled, not executed.

On pinned jsoup, all 43 corrected signatures and all 15 added relationships were source-reviewed: nine calls (five production, four test) and six production type references. No relationships were removed. The four other Compass graphs and all five Graphify graphs are byte-identical to the prior export-binding checkpoint.

Final paired run java-varargs-panel-a-02 completes all 110 unchanged requests. Scores remain Compass 49/55 versus Graphify 46/55; reviewed source paths remain 8/10 each. Selected relationship identities remain 17/21 versus 20/21, with complete reviewed occurrences 17/21 each under the disclosed corrected Click witness. This fix earns no gain on the existing comparison questions and establishes no overall superiority.

Final-source local verification: 1,351 native tests passed, zero failed, two ignored; 99 benchmark harness tests passed; workspace and focused-test Clippy passed with warnings denied; formatting, diff and product-boundary checks passed. Full final-source fixture qualification passed, including release/frontend precedence, activation, determinism and independent source-anchor checks. The preceding attempt was interrupted during release compilation; its partial log is retained and is not counted as a full pass.

A late review regression caught missing optional parameter types being mistaken for an empty parameter list. It failed before the final guard and passes afterward. The first candidate's comparison and superseded qualification are preserved; all ten final comparison graphs equal that intermediate run. Old-cache upgrade and warm reuse match clean structural records, labels and community membership, while previous-state community numeric IDs differ; no whole-graph clean/upgrade byte-equivalence claim is made.

See benchmarks/agent_query/java_varargs_development_review.json and the audit report for source, executable, graph, compiler and raw-log hashes, every added source relationship, and all limitations. Representative precision, independent confirmation, broader retrieval/navigation, functional community quality and god-object responsibility judgments remain open.

Source-backed responsibility explanation comparison

Commit 232608ee froze five natural-language questions and 20 implementation facts before executing them on the reused Chi, Click, jsoup, Redux and WalkDir graphs. Both tools received identical questions and requested 2,000-token budgets with no follow-ups. All ten requests completed. This is a development arm, not held-out evidence.

Neither first response supplies a complete explicit answer or sufficient evidence for any of the 20 full facts. Both return useful graph locations and partial relationships, but those do not establish shared state, exception cleanup, listener snapshot semantics or loop guards. No task-level mechanism assertions were made; this is a coverage gap, not a fabricated-answer finding. Source-reading and disambiguation workflows remain unmeasured.

Compass emitted 39,740 stdout bytes across the five requests; Graphify emitted 53,306. Graphify explicitly reports its 26,609-byte WalkDir response as over budget, with all 244 edge rows retained. Equal requested budgets did not produce equal output sizes. No latency comparison is claimed.

Post-output source inspection found one wrong Graphify target: IntoIter::get_deferred_dir calls pop on its Vec<DirEntry> field, but the graph points to IntoIter::pop. Compass has no corresponding wrong internal edge and retains the valid call to skippable; it does not thereby recover the external vector call. This isolated diagnosis is not an overall precision score. All other graph assertions still require a full source review before such a claim.

The frozen questions and responsibility_review_panel_a.json preserve source witnesses, response and graph hashes, all 40 per-tool fact verdicts, bounds and limitations. No new superiority, functional community quality or god-object diagnosis claim is made.

Symmetric bounded source follow-up (protocol 62f60b2; review 0b3eddd)

• All ten source reads succeeded using one returned-anchor-selected window of at most 8,000 bytes per query. Declaration ambiguity remains explicit.
• Sufficient combined evidence: Compass 11/20, Graphify 13/20; strict full-witness containment: 10/20 vs 12/20. Graphify gains two Redux facts under the earliest-anchor policy because Compass also returns preceding overload declarations.
• Source payload: 35,692 bytes each; query plus source: 75,432 vs 88,998 bytes. Initial query budgets produced unequal output sizes.
• Verified all source pins, frozen witness text, protocol/capture/raw hashes and forty fact judgments. This measures available source evidence, not model-generated explanations, native-only explanation quality, god-object labels or overall superiority.

Literal identifier retrieval and exact-name ambiguity

Commits 090140f5, 6711e3a3, and b8b1cfd2 preserve literal compound identifiers in prose, with bounded exact declared-name lookup. Ordinary words retain lexical rank. Same-name source declarations remain ambiguous across different kinds and ranking evidence; truncated exact postings cannot establish uniqueness.

• Click _AtomicFile now occupies the first exact-name seed. Redux returns all three createStore declarations as exact-name seeds, each marked ambiguous; WalkDir retains both the alias and struct as ambiguous exact matches.
• Final unchanged-graph development rerun: 110 suite requests plus ten responsibility requests, no timeouts. Recall proxy remains 49/55 Compass vs 46/55 Graphify, with no verdict changes. All existing failures remain recorded. This is an anchor-selection improvement, not evidence of better complete explanations. Chi Mux and jsoup Cleaner responses remain byte-identical.
• Final validation: 1,098 workspace tests passed, 2 ignored; 310 query tests passed (includes library tests already counted in the workspace); 37 CLI tests and 9 product tests passed. Formatting, workspace Clippy with -D warnings, and product boundary passed.
• Retained failed-before regressions cover exact provenance, truncated lookup completeness, and cross-kind name collisions. The initial validation batch was intentionally interrupted for the collision correction and is not counted as a passed baseline. Final source/binary hashes, 248 raw capture files, and log hashes are recorded in literal_identifier_development_review.json.
• No new extraction/release qualification is claimed for this query-only iteration. The earlier 11/20 vs 13/20 source-follow-up result belongs to its frozen pre-change workflow. Full graph precision, fresh held-out evaluation, god-object diagnosis, functional community quality, and overall superiority remain unproven.

Source-defined community task pairs

Commits 234753eb and bef1d765 freeze and audit 30 source declarations across Chi, Click, jsoup, Redux and WalkDir. All 30 resolve uniquely in both unchanged native graph artifacts. This is a development artifact audit, not a native answer workflow, independent semantic review or god-object oracle.

• Within-task collaborator pairs co-located: 13/15 Compass vs 12/15 Graphify. Both cross-file collaborator pairs are co-located on both sides.
• Cross-task pairs co-located: 18/60 vs 12/60. These describe granularity, not false positives or a combined accuracy score. Click help layout uses the terminal-width helper; WalkDir's different mechanisms share iterator state.
• All five split collaborator pairs retain the expected source-supported direct call edge: Compass Click term_len -> strip_ansi, both tools' jsoup isBlank -> isWhitespace, and Graphify's jsoup clean -> copySafeNodes and parseBodyFragment -> parseFragment. These splits are not missing-call findings.
• All 109 developer-harness tests pass, including ten new cases covering exact anchors, ambiguous/missing identities, zero-valued community IDs, bounds and ordering invariance. The final auditor reproduces all 150 tool/pair outcomes; raw captures, hashes and source boundary witnesses are retained. Rust/product tests were not rerun for this Python/data/docs-only iteration.
• No clustering algorithm changed. The next evidence is public navigation across community boundaries, plus broader source responsibility review and genuine god-object positive cases. Overall superiority and full community quality remain unproven.

Community-to-neighbor workflow (frozen development arm)

Protocol commit 7a6d6c97 freezes all 15 source-defined tasks before capture.
Both tools start at their prepared seed community, then receive at most one
get_neighbors call whose label comes only from returned community text.
No graph-derived follow-up ID or ambiguity retry is substituted.

Measure	Compass	Graphify
Stored community membership reproduced	15/15	15/15
Unambiguous follow-up label selected	13/15	15/15
Seed identity supported	5/15	9/15
Reviewed direct collaborator identity supported	4/14	8/14
Required direct-call graph pairs present	13/14	14/14

All 58 issued public tool calls succeeded; two Compass follow-ups were skipped
for distinct matching member labels. Compass's broader matcher makes unique
RequestID(), term_len() and .follow() labels ambiguous. Several genuine
collisions affect both tools. Successful ambiguity responses often provide
candidate IDs; longer disambiguation workflows remain unmeasured. Compass also
lacks the source-supported WalkDir push -> DirList.close call at line 906 in
this frozen graph; this is separate from community grouping.

Common external bounds are 60 seconds and 1 MiB per response, with Graphify's
generous explicit token budget and Compass's whole-result interface disclosed.
Call text totals are 145,715 vs 51,605 bytes; full session bytes including
startup/listing/requests/stderr are 238,216 vs 94,443. Different community sizes
and success counts prevent matched-success efficiency claims. No timeout or
cap failure occurred.

All 119 developer-harness tests pass, including ten new regressions. Separate
same-agent transcript/hash/count recomputation agrees. The complete per-task
review is benchmarks/agent_query/community_navigation_review_panel_a.json;
raw evidence is retained in community-navigation-01. No Rust/product changes
or Rust tests in this iteration. Product remains 0.3.30; no merge or release.
These reused-repository results do not establish held-out performance,
comprehensive precision, god-object diagnosis or overall superiority.

Exact-first MCP neighbor correction and fixed-graph rerun

Commit 8f5eb5e5 makes get_neighbors use the existing exact-ID/symbol matcher
before broad prefix/substring fallback. Genuine exact collisions remain
ambiguous with stable, bounded candidate lists. Graph extraction, clustering,
public schemas and version 0.3.30 are unchanged.

The unchanged frozen 15-task community-to-neighbor workflow now reports:

Measure	Compass before	Compass after	Graphify
Seed identity supported	5/15	8/15	9/15
Reviewed direct collaborator supported	4/14	6/14	8/14

Chi RequestID, Click term_len and WalkDir follow now resolve their exact seed.
All ten graph hashes, follow-up labels and community texts are unchanged;
Graphify neighbor responses are byte-identical. No supported seed/collaborator
regresses. Graphify remains ahead in this arm. Two ambiguous community
selectors, five genuine neighbor ambiguities and the missing WalkDir
push-to-close edge remain open. Source-qualified/ID follow-ups need a separate
fair arm; this label-only workflow is not a best-possible navigation score.

Validation: 58 MCP tests, 1,101 workspace library/binary tests (two ignored),
nine product tests, formatting, workspace Clippy with warnings denied, product
boundary, CLI build and 120 developer-harness tests pass. The 38 MCP library
tests overlap the workspace count. The initial failing regressions and an
unrelated stale RESULT-header assertion are retained; the latter now verifies
transport text against the shared rendered Agent View. A verifier also found
unstable ordering in older missing-neighbor audit diagnostics; sorting is
regression-tested, and recapture retains identical tool packets and verdicts.

Full per-task results and provenance:
benchmarks/agent_query/neighbor_exact_match_review_panel_a.json.
No release, merge, overall-superiority claim or held-out claim. Broader source
precision, god-object judgments, community quality and longer walks remain open.

Stronger source-assisted public navigation arm

Protocol f660408b freezes an equal one-resolver/one-neighbor allowance after
community membership. Compass uses structured search_symbols; Graphify uses
get_node with its documented path::symbol form. Both policies receive the
same exact seed file, declaration start and terminal symbol. Only a uniquely
source-matched returned ID becomes the neighbor request; no graph ID is
substituted and the expected collaborator cannot gate navigation.

Measure	Compass	Graphify
Correct returned seed IDs and completed neighbor lookups	15/15	15/15
Reviewed outgoing collaborator label present	13/14	14/14
Unambiguous target label after validated seed lookup	10/14	11/14

This is counterevidence to treating earlier label-only failures as inability
to navigate: the existing resolver APIs overcome them with this extra step and
supplied source coordinates. No product code changed in this arm. Legacy
neighbor bodies still do not explicitly identify their seed, and three target
labels remain ambiguous in both tools (Click close, jsoup parseFragment and
isWhitespace). The remaining reviewed graph gap is Compass's WalkDir
push-to-DirList.close call at line 906.

All 90 public calls succeed; all 129 developer-harness tests pass. Separate
same-agent transcript/source-coordinate/graph-ID recomputation agrees. Final
recapture preserves all 90 response packets and 30 task audits after ensuring
missing target-oracle data cannot suppress seed navigation. The five pinned
source checkouts remain clean.

Full session bytes are 785,989 for Compass versus 102,213 for Graphify under
this policy. Compass search returns more candidates and structured evidence;
these costs are real but native controls and payloads differ. This is not an
equal-token, natural-language discovery, held-out or overall-superiority result.
The complete review is
benchmarks/agent_query/community_identity_navigation_review_panel_a.json.
Next: the Rust indexed-receiver call gap, explicit destination identities and
bounded resolver cost. God-object judgments and broader precision remain open.
Version remains 0.3.30; no merge or release.

Rust indexed-receiver recovery — validated development replay

Implementation 18bb37ea adds bounded source-type inference for Rust indexed receivers and preserves declaration scope and nested type paths. Unsupported or ambiguous cases remain unresolved. AST cache semantics advance from 6 to 7; Compass remains at 0.3.30.

The frozen protocol rebuilds all five Compass graphs from the same pinned sources and replays the same 15 public navigation tasks. Full graph-record comparison and source review find exactly one added call: WalkDir IntoIter::push → DirList::close at src/lib.rs:906. No existing graph records or community assignments change; the other four Compass graphs are byte-identical. Graphify graph artifacts are reused unchanged, and its public MCP responses are recaptured.

Compass now ties Graphify at 14/14 reviewed collaborator labels and 11/14 globally unambiguous target labels. Three target-label ambiguities remain for each tool. This is a development correction; broad source precision, god-object diagnosis, longer directed walks and held-out superiority remain unproven.

Final unchanged-source validation passed: formatting; 38 Rust language tests; 211 resolver tests; workspace Clippy; 1,101 workspace tests (2 ignored); 9 product tests; product-boundary check; complete production fixture qualification; and 129 Python harness tests. The evaluated binary matches the final build byte-for-byte.

Protocol, results, limitations and validation log hashes are recorded in benchmarks/agent_query/rust_index_receiver_development_review.json and the implementation audit document. Audit record commit: a07ab991.

Explicit neighbor identities — verified development replay

Implementation d51698dc adds compass.query.neighbors/1 to MCP get_neighbors: exact seed/destination node records and every matching relationship record, preserving direction, source anchors, provenance and parallel occurrences. Work and response bounds fail explicitly. Compact text remains available, with escaped identity/source lines. Version remains 0.3.30.

Protocol bde19bb3 reuses the same ten frozen graph artifacts and 15 source-defined tasks across Chi, Click, jsoup, Redux and WalkDir. The separate transcript verifier confirms all 15 Compass projections match their graphs (181 relationship-record appearances).

• Explicit destination ID in the neighbor response: Compass 14/14; Graphify does not emit neighbor IDs (0/14).
• With one additional source-anchored public resolver call, both tools resolve 14/14 destinations. Supplied target coordinates make this a source-assisted lookup, not autonomous edge disambiguation.
• Legacy collaborator labels remain 14/14, and globally unambiguous target labels remain 11/14 for both.
• All 118 public calls succeed (59 per tool). Response-wire totals are 1,228,383 bytes for Compass and 63,756 for Graphify; richer native payloads differ. This is a direct-response identity improvement, not overall superiority or equal-content efficiency.

Final validation passed: formatting; 3 focused query tests; all 60 MCP tests; workspace Clippy; 1,106 workspace tests (2 ignored); 9 product tests; product boundary; complete production fixture qualification; final CLI build; and 134 Python harness tests. The evaluated binary matches the final build byte-for-byte.

Results and artifact hashes: benchmarks/agent_query/neighbor_identity_development_review.json, audit commit 8eb1bf0f. Graph consistency does not establish broad source precision. God-object judgments, richer source explanations, longer directed walks and fresh held-out confirmation remain outstanding.