fix(graph): IMPORTS edges keyed by local_name across buffer, store and dump

[DeusData]

fix(graph): IMPORTS edges keyed by local_name across buffer, store and dump

Distills #770 (author: Alexandros Pappas, @apappas1129 — credited via
Co-authored-by) and completes the edge-uniqueness contract that the PR
changed in only one of its three homes.

What was broken

A single import { A, B } from './lib' produced exactly one IMPORTS edge.
The graph buffer dedups edges on (source_id, target_id, type), and both
named imports resolve to the same (source_file, target_file) pair — so the
second symbol's edge collided with the first and merge-replaced its
properties, silently dropping whichever import lost the write race.

Blast radius is bigger than "who imports X" queries: pass_calls.c,
pass_usages.c, pass_semantic.c and pass_lsp_cross.c all parse exactly
one local_name out of each IMPORTS edge to build their local-name →
module-QN maps, so the dropped symbol's cross-file call resolution broke
too.

The three-site contract

Edge uniqueness is defined in three places that must agree. #770 fixed only
the first; as-is it ships databases that violate their own UNIQUE constraint
(PRAGMA integrity_check: non-unique entry in index sqlite_autoindex_edges_1).

Site	Old contract	New contract
src/graph_buffer/graph_buffer.c make_edge_key() (dedup hash key; 3 call-sites: insert, unindex, delete-by-type)	src:tgt:type	src:tgt:type:local_name for IMPORTS only
src/store/store.c edges DDL + cbm_store_insert_edge upsert	UNIQUE(source_id,target_id,type), matching ON CONFLICT	+ local_name_gen VIRTUAL generated column (CASE WHEN type='IMPORTS' THEN coalesce(json_extract(properties,'$.local_name'),'') ELSE '' END), UNIQUE(...,local_name_gen), conflict target widened to match
internal/cbm/sqlite_writer.c (raw dump: DDL text + hand-built sqlite_autoindex_edges_1 comparator + entry builder)	3-column autoindex	4-column DDL/comparator/entries; CBMDumpEdge.local_name extracted via yyjson so entries match json_extract's unescaped values (same precedent as idx_edges_url_path)

Details:

• IMPORTS-only discriminator. Non-IMPORTS edges keep their existing
  collapse-repeats dedup; their local_name_gen is '' (NOT NULL —
  NULLs never conflict in a UNIQUE index, which would have broken
  non-IMPORTS dedup entirely).
• Audit nit from fix(graph): key IMPORTS edge dedup on local_name, not just source/target #770 addressed (EDGE_KEY_BUF truncation):
  buffer bumped CBM_SZ_128 → CBM_SZ_256, and a local_name too long for
  the buffer is re-keyed with an FNV-1a-64 hash of the FULL name instead
  of being silently truncated — two long names sharing a prefix can no
  longer collide back into one edge. The hash key is prefixed with byte
  0x01, which cannot occur in a raw JSON slice, so hash keys can never
  collide with verbatim keys.
• Idempotency preserved: re-inserting the same
  (src, tgt, IMPORTS, local_name) still dedups in the buffer and still
  upserts (json_patch) in the store.

Schema migration

There is no in-place migration mechanism for SQLite table constraints
(ALTER TABLE cannot touch a table-level UNIQUE), and the codebase's
established pattern for incompatible DBs is fail open → rebuild:

• init_schema now probes for edges.local_name_gen and fails the open on
  pre-existing old-schema DBs (store.schema result=incompatible).
  try_incremental_or_delete_db already treats an unopenable DB as
  incompatible and deletes + rebuilds it on the next full index;
  artifact import refuses and falls back to a reindex.
• Read-only query opens (cbm_store_open_path_query) skip init_schema
  and keep working on old DBs — only writes force the rebuild.
• CBM_ARTIFACT_SCHEMA_VERSION 1 → 2 (the header's documented "increment
  when DB schema changes" gate): old binaries refuse artifacts carrying the
  widened schema — their 3-column ON CONFLICT target can no longer prepare
  against it.

Tests (reproduce-first)

All new tests were written first and run against unmodified main
(red evidence verbatim below), then against the intermediate state
(gbuf fix only = #770's scope), then the full fix.

Test (tier)	main (unfixed)	gbuf fix only (#770 as-is)	full fix
gbuf_imports_multi_symbol_dedup (graph_buffer, from #770)	FAIL tests/test_graph_buffer.c:192: eid_a == eid_b (both 3)	PASS	PASS
gbuf_imports_long_local_name_no_collision (graph_buffer, new)	FAIL tests/test_graph_buffer.c:244: eid_a == eid_b (both 3)	PASS	PASS
store_imports_edge_local_name_coexist (store_edges)	FAIL tests/test_store_edges.c:104: ida == idb (both 1)	same FAIL	PASS
sw_imports_local_name_unique (sqlite_writer)	FAIL tests/test_sqlite_writer.c:185: "non-unique entry in index sqlite_autoindex_edges_1" != "ok" ¹	same FAIL	PASS
pipeline_imports_multi_symbol_edges (pipeline, end-to-end TS fixture)	FAIL tests/test_pipeline.c:1739: count == 1, expected 2 == 2	FAIL tests/test_pipeline.c:1727: "non-unique entry in index sqlite_autoindex_edges_1" != "ok"	PASS

¹ Run with the .local_name initializers commented out, since the field
does not exist on main (the struct gains it in this change).

The bolded intermediate-state failure is the guard proving the schema half
matters: with only #770's buffer fix, the real pipeline dumps both edges into
a DB whose own UNIQUE(source_id, target_id, type) they violate.

Verification

• make -f Makefile.cbm cbm — -Werror clean
• make -f Makefile.cbm lint-ci — cppcheck + clang-format + NOLINT check passed
• Suites green (0 failures): graph_buffer, store_edges, sqlite_writer
  (82), pipeline (210), and the wider affected set store_nodes,
  store_search, store_arch, store_bulk, store_pragmas,
  store_checkpoint, artifact, dump_verify, dump_verify_io, cypher,
  mcp, incremental, integration, edge_imports, edge_structural,
  watcher, cli (924)

Closes #768.