Walking skeleton — end-to-end precision thread

Goal

Prove the precision pipeline end-to-end with one de-noised CALLS edge class, one corrected MISSING_ABSTRACTION edge, and one new query primitive consumed by /impl-hygiene-review.

Implementation Sketch

Take the smallest slice of calls-resolution-precision (s-1209f1e9; callable-kind filter) + semantic-dup-correctness (s-a04ca9c6; one HNSW-cosine edge) + query-primitives (s-9fb83bc7; god-functions primitive) and thread all THREE slices through the /impl-hygiene-review phase-2.5 recon consumer. This is the linear-DAG root; it proves the ingest->query->consumer path before the deep sections build on it.

Sections are addressed by slug ID, not positional number; the god-functions primitive lives in query-primitives (s-9fb83bc7).

This root owns the END-TO-END THREAD, not the production deliverables. Each slice here is a minimal proof-of-pipe; the full production deliverable for each lives in its owning section — the callable-kind resolver in s-1209f1e9, the HNSW-cosine semantic-dup fix in s-a04ca9c6, and god-functions plus the full recon pre-pass in s-9fb83bc7.

Threading three subsystems is the walking-skeleton pattern (linear-DAG root per plan-schema §Walking-Skeleton Root), not scope creep.

Because the skeleton threads all three slices, its proof-of-pipe must pin all three: the de-noised CALLS edge (extend-collision edges == 0), the corrected MISSING_ABSTRACTION cosine edge (the verify_trmc_soundness/linker_args false-pair-absent check), and the god-functions primitive returning through the consumer pre-pass.

Work Items

• Minimal callable-kind filter slice in import_code_graph.py:_resolve_target_py that drops the extend-collision edge class.
• Correct ONE MISSING_ABSTRACTION edge by routing a single pair through the HNSW symbol_embedding cosine (proof-of-pipe).
• Wire ONE new query primitive (god-functions) in intel_repo/neo4j/query_graph.py PLUS a minimal proof-of-pipe consumer that calls it from the /impl-hygiene-review phase-2.5 recon pre-pass — enough to prove the ingest->query->consumer path threads end-to-end. This work item is scoped to the primitive wiring + the minimal proof consumer ONLY. The FULL phase-2.5-graph-recon consumer integration (the production recon pre-pass that feeds candidate symbol-sets into the reviewer) lands in query-primitives (s-9fb83bc7) and is routed through scripts/impl_hygiene_review_runtime/ (dispatch/state/prompts + next_action.schema.json + pytest) per script-first.md — NOT as inline /impl-hygiene-review skill-body prose. The skeleton takes only a proof-of-pipe slice here; the full hook is a forward deliverable elaborated in query-primitives (s-9fb83bc7), not a prerequisite of this root section.

Graph-unavailability degradation

The recon pre-pass and the new query primitives MUST degrade gracefully when Neo4j is unavailable, consistent with scripts/intel-query.sh’s graceful-degradation contract: the recon pre-pass returns no candidates (degrades to no-candidates) and /impl-hygiene-review continues WITHOUT the graph-recon signal. A graph-down state NEVER halts the reviewer — the consumer treats an unavailable graph as an empty candidate set, not an error.

Test coverage

Shell probes alone do not pin regressions (per tests.md). The end-to-end pipe is covered by automated pytest in BOTH intel_repo and scripts/impl_hygiene_review_runtime plus a production-entry consumer test driving the real /impl-hygiene-review recon pre-pass.

Coverage matrix (assertion × pipeline layer):

This coverage is pinned by success criterion sc-ad1d4067 (owned by this section) and is written test-first as part of each work item above — the failing pytest frames the slice before the slice is implemented, per the matrix-testing rule.

References

intel_repo/neo4j/import_code_graph.py; intel_repo/neo4j/query_graph.py; intel_repo/neo4j/metrics.py; scripts/intel-query.sh; scripts/impl_hygiene_review_runtime/; .claude/skills/impl-hygiene-review/.