diff --git a/.erpaval/INDEX.md b/.erpaval/INDEX.md
index c394b444..1c1222dd 100644
--- a/.erpaval/INDEX.md
+++ b/.erpaval/INDEX.md
@@ -44,6 +44,8 @@ development sessions. Solutions are reusable; specs are per-feature.
 - [Smoke-testing a workspace cli requires packing every publishable workspace dep](solutions/best-practices/workspace-tarball-pack-all-publishables.md) — `npm install -g <cli.tgz>` falls back to registry for un-packed transitive workspace deps, dragging in the previously-published versions and masking install-graph regressions. Pack everything publishable, every time.
 - [GitHub Actions top-level permissions cap every job](solutions/conventions/workflow-call-permissions-ceiling.md) — workflow's top-level `permissions:` is a ceiling; per-job blocks can narrow but not grant. `id-token: write` declared at job level silently no-ops if missing from top level. Diagnostic: read the "GITHUB_TOKEN Permissions" group in the failing job's log.
 
+- [lbug COPY FROM (subquery) bulk-load pattern](solutions/conventions/lbug-copy-from-subquery-bulk-load.md) — type-safe bulk inserts via COPY subquery; sentinel row, STRING[] never null + sentinel STRING[] never empty (LIST(ANY) trap), maxDBSize cap (8 TiB default exhausts VA), readOnly cannot run CREATE_FTS_INDEX, src/dst not from/to, eid not id alias.
+
 ## Specs
 
 - [001-scip-replaces-lsp](specs/001-scip-replaces-lsp/spec.md) — rip-and-replace LSP with SCIP for TS/Py/Go/Rust/Java. Task map: [tasks.md](specs/001-scip-replaces-lsp/tasks.md).
diff --git a/.erpaval/solutions/conventions/lbug-copy-from-subquery-bulk-load.md b/.erpaval/solutions/conventions/lbug-copy-from-subquery-bulk-load.md
new file mode 100644
index 00000000..46b2807f
--- /dev/null
+++ b/.erpaval/solutions/conventions/lbug-copy-from-subquery-bulk-load.md
@@ -0,0 +1,102 @@
+---
+name: lbug-copy-from-subquery-bulk-load
+description: lbug v0.16.1 COPY FROM (subquery) pattern for type-safe bulk node+edge inserts — avoids INT64/DOUBLE confusion, sentinel pattern, and from/to keyword collision
+metadata:
+  type: project
+---
+
+## Pattern: `COPY <Table> FROM (UNWIND $rows AS r ... RETURN ...)`
+
+lbug v0.16.1's `UNWIND` + `CREATE/MERGE` path infers struct-field types per-row
+from JS values (`Number.isInteger(v) → INT64`, else `DOUBLE`). Any confidence=1.0
+edge lands as INT64 bit-pattern in a DOUBLE column and round-trips as garbage.
+
+**Fix**: `COPY <Table> FROM (UNWIND $rows AS r WITH r WHERE r.id <> '<SENTINEL>' RETURN ...)`.
+COPY reads column types from the DDL; CAST in the RETURN clause converts string-encoded
+numerics to the correct type; per-row inference never runs.
+
+### Node inserts
+
+```cypher
+COPY CodeNode FROM (UNWIND $rows AS r
+  WITH r WHERE r.id <> '__SENTINEL__'
+  RETURN r.id, r.kind, ..., CAST(r.start_line AS INT32), ..., CAST(r.cohesion AS DOUBLE), ...)
+```
+
+Row encoding rules:
+- INT32 columns: pass value as `String(Math.trunc(v))` or `null`
+- DOUBLE columns: pass value as `String(v)` or `null`  
+- BOOL columns: pass `true`/`false`/`null`
+- STRING[] columns: **never pass `null`** — pass `[]` for absent arrays, or lbug infers
+  LIST(ANY) and throws "Trying to create a vector with ANY type"
+- STRING columns: pass string value or `null`
+
+Sentinel row requirement: prepend a row with `id = SENTINEL_ID` and concrete typed values
+for every column (strings for numerics, `false` for bools, `[]` for string arrays, `""` for
+strings). The `WITH r WHERE r.id <> SENTINEL_ID` filters it before any storage write.
+Purpose: seeds struct-field type inference for lbug's binder so all-null batches don't fail.
+
+### Edge inserts
+
+```cypher
+COPY DEFINES(id, confidence, reason, step) FROM (UNWIND $rows AS r
+  WITH r WHERE r.eid <> '__EDGE_SENTINEL__'
+  RETURN r.src, r.dst, r.eid, CAST(r.confidence AS DOUBLE), r.reason, CAST(r.step AS INT32))
+```
+
+Critical rules:
+- Use `src`/`dst` (not `from`/`to`) as struct field names — `from` and `to` are Cypher
+  reserved keywords; lbug silently misinterprets `r.from`/`r.to` in a RETURN clause
+- Use `eid` (not `id`) for the edge id field in the row struct — lbug matches column name
+  `id` against the CodeNode primary key and tries to do a node lookup instead of treating
+  it as a rel property. Alias `r.eid` maps to the `id` rel property via positional column list
+- The `COPY E(id, confidence, reason, step)` column list is required to bind positional
+  RETURN columns to rel properties correctly
+- Sentinel's `src`/`dst` can be empty strings `""` — filtered by `WHERE r.eid <> SENTINEL`
+
+### Compatibility notes
+
+- `COPY FROM (subquery)` requires the subquery to have a RETURN clause
+- `WITH r WHERE` inside UNWIND is valid Cypher inside a COPY subquery
+- `IGNORE_ERRORS=true` silently drops rows where FROM/TO node lookup fails — avoid using
+  it as a crutch; fix the sentinel instead so the sentinel itself is filtered before lookup
+- The mmap "Buffer manager exception: Mmap for size 8796093022208 failed" is virtual
+  address-space exhaustion. lbug's default `maxDBSize` is `1 << 43` = 8 TiB per
+  `Database`; on 64-bit Linux the user has ~128 TiB of VA, so ~16 concurrent DBs
+  exhaust the address space (kernel `MAP_FAILED`). Fix: pass an explicit
+  `maxDBSize` (5th `Database` ctor arg, MUST be a power of 2) — 16 GiB is plenty
+  for OCH-scale graphs and drops virtual reserve 512×. Also pass `bufferManagerSize`
+  (2nd arg) — native default is `min(systemMem, maxDBSize) * 0.8`, often >50 GiB;
+  cap at 2 GiB for headroom across concurrent test pools without surfacing the
+  sibling error "Buffer manager exception: Unable to allocate memory! The buffer
+  pool is full and no memory could be freed!" Cite: kuzudb/kuzu#1826.
+- `Database.close()` is what triggers `~VMRegion` → `munmap()`; relying on JS GC
+  alone leaks the mapping between tests. Always `await db.close()` before opening
+  the next instance pointing at a different path.
+
+### "Trying to create a vector with ANY type" — sentinel STRING[] must be non-empty
+
+The lesson above says STRING[] columns must never be `null` and should be `[]` for
+absent arrays. That handles per-row binding, but the **sentinel row's** STRING[]
+fields must additionally be **non-empty** (e.g. `["__sentinel__"]`) — lbug's
+struct-field type inference looks at the FIRST row's array contents to fix the
+LIST element type. An empty-array sentinel (`[]`) yields `LIST(ANY)`, and any
+later data row with a string then throws "Trying to create a vector with ANY type".
+The seed value never reaches storage because `WITH r WHERE r.id <> SENTINEL`
+filters the row before COPY. Reproduces with a 3-column table and 3 rows:
+sentinel `kw=[]`, n1 `kw=[]`, n2 `kw=["a","b"]` → fails. Switching the
+sentinel to `kw=["__seed__"]` fixes it.
+
+### Read-only opens cannot run `CALL CREATE_FTS_INDEX` / `CALL CREATE_VECTOR_INDEX`
+
+lbug rejects writes against a Database opened with `readOnly=true`, including the
+`CALL CREATE_FTS_INDEX(...)` and `CALL CREATE_VECTOR_INDEX(...)` admin procedures
+that adapters use to ensure search-side indexes exist. Surfaces as "Cannot
+execute write operations in a read-only database!" the moment a reader calls
+`search()` or `vectorSearch()`. Fix: build both indexes at the end of `bulkLoad`
+(when the connection is read-write) and have the lazy-ensure helpers no-op in
+readOnly mode. Readers query the existing index; the index already exists
+because every write path runs through bulkLoad.
+
+**Why:** [[scip-replaces-lsp]] — same pattern of lbug's binding layer having non-obvious
+per-row type inference that requires careful workarounds.
diff --git a/CLAUDE.md b/CLAUDE.md
index 83664f14..73db824c 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -80,19 +80,25 @@ This repo ships a Claude Code plugin at `plugins/opencodehub/` — it
 provides a `code-analyst` subagent and 10 skills. Install via
 `codehub init` (writes `.mcp.json` + links the plugin).
 
-## Storage backend — graph-default
-
-`CODEHUB_STORE` is unset by default. OpenCodeHub probes
-`@ladybugdb/core` and uses the graph-database backend when the binding
-is available; otherwise it falls back to DuckDB with a one-shot stderr
-advisory (gated on TTY or `OCH_VERBOSE=1`). Set `CODEHUB_STORE=duck` to
-force the legacy layout (single DuckDB file backs both graph + temporal
-views) or `CODEHUB_STORE=lbug` to require the graph-database backend.
-
-When both `graph.duckdb` and `graph.lbug` exist as siblings in the same
-`<repo>/.codehub/`, the newer-mtime file wins. See ADR 0013
-(`docs/adr/0013-m7-default-flip-and-abstraction.md`) for the rationale
-and the AGE/Memgraph/Neo4j/Neptune community-adapter escape hatch.
+## Storage backend — lbug graph + DuckDB temporal
+
+The graph tier is always `@ladybugdb/core` (`graph.lbug`); the temporal
+tier — cochanges, structured symbol summaries, and the
+`codehub query --sql` escape hatch — is always DuckDB
+(`temporal.duckdb`). Both files live under `<repo>/.codehub/`. There is
+no env-var, no probe, no fallback; if the lbug binding fails to load,
+`open()` throws `GraphDbBindingError` and the operation aborts. See
+ADR 0016 (`docs/adr/0016-duckdb-graph-rip.md`) for the rationale and the
+AGE/Memgraph/Neo4j/Neptune community-adapter contract that survives the
+rip-out (the segregated `IGraphStore` / `ITemporalStore` interfaces stay
+exactly because community-fork adapters are a deliberate escape hatch).
+
+`IGraphStore` lives only on `GraphDbStore`; `DuckDbStore` implements
+`ITemporalStore` only. Embeddings live in `graph.lbug` and stream into a
+per-call DuckDB temp table at pack time so the byte-identical Parquet
+sidecar still works (see `packages/pack/src/embeddings-sidecar.ts`).
+Future temporal swap (e.g. SQLite-WASM) only needs a new `ITemporalStore`
+implementor — no graph-tier change.
 
 ## Parse runtime — WASM-only, vendored grammars
 
diff --git a/docs/adr/0011-graph-db-backend.md b/docs/adr/0011-graph-db-backend.md
index 0851b40f..4d48ade9 100644
--- a/docs/adr/0011-graph-db-backend.md
+++ b/docs/adr/0011-graph-db-backend.md
@@ -1,6 +1,11 @@
 # ADR 0011 — Graph-DB backend (LadybugDB phase-1)
 
-- Status: **Accepted** — 2026-05-05 (Proposed) → flipped on the M3 merge.
+- Status: **Partially superseded** by [ADR 0016](./0016-duckdb-graph-rip.md)
+  on 2026-05-16. The "DuckDB-default plus LadybugDB opt-in" framing is
+  obsolete; lbug is the unconditional graph backend after the rip. The
+  LadybugDB integration shape and `IGraphStore` design introduced here
+  are unchanged.
+- Was: **Accepted** on 2026-05-05 and flipped on the M3 merge.
 - Authors: Laith Al-Saadoon + Claude.
 - Branch: `feat/v1-m3-m4`.
 - Supersedes nothing. Interacts with ADR 0001 (DuckDB backend stays the
diff --git a/docs/adr/0013-m7-default-flip-and-abstraction.md b/docs/adr/0013-m7-default-flip-and-abstraction.md
index 8affdae5..e05e68c3 100644
--- a/docs/adr/0013-m7-default-flip-and-abstraction.md
+++ b/docs/adr/0013-m7-default-flip-and-abstraction.md
@@ -5,7 +5,13 @@
 > in-tree because they were authored in parallel branches and accepted
 > on the same release. The next ADR uses 0014.
 
-- Status: **Accepted** — 2026-05-09 (Proposed) → flipped on the
+- Status: **Superseded** by [ADR 0016](./0016-duckdb-graph-rip.md)
+  on 2026-05-16. The auto-probe, dual-artifact arbitration, and
+  `CODEHUB_STORE` resolver introduced here are gone. lbug is the only
+  graph backend; DuckDB serves the temporal tier. The
+  IGraphStore/ITemporalStore segregation survives because community
+  adapters (AGE, Memgraph, Neo4j, Neptune) target it.
+- Was: **Accepted** on 2026-05-09 and flipped on the
   `feat/v1-finalize-track-a` merge (PR #71).
 - Authors: Laith Al-Saadoon + Claude.
 - Branch: `feat/v1-finalize-track-a`.
diff --git a/docs/adr/0016-duckdb-graph-rip.md b/docs/adr/0016-duckdb-graph-rip.md
new file mode 100644
index 00000000..f766be6d
--- /dev/null
+++ b/docs/adr/0016-duckdb-graph-rip.md
@@ -0,0 +1,146 @@
+# ADR 0016 — Rip out the DuckDB graph backend; lbug-only graph, DuckDB temporal-only
+
+- Status: **Accepted** — 2026-05-16.
+- Authors: Laith Al-Saadoon + Claude.
+- Branch: `feat/duckdb-graph-rip`.
+- Supersedes: [ADR 0013 — M7 default flip and storage abstraction](./0013-m7-default-flip-and-abstraction.md)
+  in its entirety; partially supersedes [ADR 0011 — graph-db backend](./0011-graph-db-backend.md)
+  (the "DuckDB-as-graph default" passages).
+
+## Context
+
+ADR 0011 introduced `@ladybugdb/core` (lbug) as a second `IGraphStore`
+backend behind a `CODEHUB_STORE` env-var selector. ADR 0013 flipped the
+default to graph-default with auto-probe-and-fallback semantics: when
+`CODEHUB_STORE` was unset, the resolver imported `@ladybugdb/core` and
+preferred lbug on success, otherwise fell back to DuckDB-as-graph. A
+dual-artifact detector picked the newer-mtime file when both
+`graph.duckdb` and `graph.lbug` existed in `<repo>/.codehub/`. The
+DuckDB graph adapter therefore lived as a permanent fallback path,
+maintained alongside the lbug adapter.
+
+Two things changed at the start of the 2026-05 dogfood cycle:
+
+1. **lbug bulk-load became feature-complete.** A separate session landed
+   the `COPY <Table> FROM (UNWIND $rows ...)` pattern that DuckDB
+   already had — type-safe ingestion of nodes and edges through lbug's
+   bulk path. After that, every `IGraphStore` surface — bulk-load, all
+   15 typed finders, BM25 search, HNSW vector search, traversals,
+   embeddings — runs on lbug; the v1.0 conformance suite passes against
+   lbug; the cross-adapter parity tests existed only to keep DuckDB
+   honest.
+2. **The dual-write code carried real cost.** ~1900 LOC of graph-tier
+   code in `duckdb-adapter.ts`, the ~3500-LOC parity test suite, the
+   resolver/probe/dual-artifact apparatus, the env-var, the docs that
+   tried to keep `codehub-graph` as a backend axis. Every `analyze`
+   path took two branches and every architectural claim ("storage is
+   pluggable") had to defend a backend that nobody set explicitly.
+
+The user's framing was "rip out the DuckDB fallback for graph store …
+keep the generic / abstractions but I don't want all this code for
+duckdb unless it's the temporal/genuine tabular type stuff. and in fact
+maybe even that should be sqlite wasm or something."
+
+## Decision
+
+**`IGraphStore` lives only on `GraphDbStore`; `DuckDbStore` implements
+`ITemporalStore` only.** The interface segregation introduced in
+session-33f24f (see
+[`solutions/architecture-patterns/igraphstore-itemporalstore-segregation.md`](../../.erpaval/solutions/architecture-patterns/igraphstore-itemporalstore-segregation.md))
+was anticipating exactly this split — community AGE / Memgraph / Neo4j /
+Neptune adapters target `IGraphStore` only and pair with the
+DuckDB-backed `ITemporalStore`. After this rip-out, that's also the
+in-tree shape: lbug owns `IGraphStore`, DuckDB owns `ITemporalStore`,
+and the in-tree adapters stop demonstrating the structural-typing-via-
+`implements both` case.
+
+Concrete shape after the rip:
+
+- `openStore({path})` always returns `{graph: GraphDbStore, temporal:
+  DuckDbStore, graphFile, temporalFile, close}`. No `backend` field on
+  the result envelope; no `backend?` option on the input.
+- The graph artifact is `<dir>/graph.lbug`. The temporal artifact is
+  `<dir>/temporal.duckdb`. `paths.describeArtifacts()` takes no arguments
+  and returns `{graphFile: "graph.lbug", temporalFile: "temporal.duckdb"}`.
+- `resolveDbPath` is renamed `resolveGraphPath` and returns the lbug
+  filename.
+- `CODEHUB_STORE` is gone. The env var is no longer consulted anywhere
+  in storage. The resolver, the dynamic-import probe of `@ladybugdb/core`,
+  the dual-artifact mtime arbitration, the `_lbugFallbackWarned` /
+  `_dualArtifactWarned` advisory state, and the
+  `_resetStoreResolverCache` test escape hatch are all deleted.
+- The MCP `sql` tool's `cypher` field becomes unconditionally available;
+  it routes to `store.graph.execCypher(...)`.
+- Embeddings live in `graph.lbug`. The pack embeddings sidecar streams
+  rows from `store.graph.listEmbeddings()` into a per-call DuckDB
+  `CREATE TEMP TABLE embeddings_export` on `temporal.duckdb`, then runs
+  the existing deterministic
+  `COPY (... ORDER BY ...) TO '<path>' (FORMAT PARQUET, COMPRESSION ZSTD)`,
+  then drops the temp table. The byte-identity contract for
+  `embeddings.parquet` is preserved.
+- The conformance suite at `packages/storage/src/test-utils/conformance.ts`
+  (`assertIGraphStoreConformance(name, factory)`) and the parity-harness
+  rebuilder at `packages/storage/src/test-utils/parity-harness.ts` stay.
+  They are the v1.0 contract for community adapters; deleting them
+  would contradict the segregation ADR's promise.
+
+## Backwards compatibility
+
+None. Existing `<repo>/.codehub/graph.duckdb` files are no longer read.
+Users re-run `codehub analyze` to write `graph.lbug` from scratch.
+There is no stale-artifact warning, no legacy alias, no kill-switch.
+This is a single-user dogfood repo today; the cost of a hard cutover is
+"re-run analyze once."
+
+## Operational impact
+
+- **Platform reach narrows to lbug's 5 prebuilt targets**:
+  `darwin-arm64`, `darwin-x64`, `linux-arm64`, `linux-x64`, `win32-x64`.
+  Alpine/musl and 32-bit Linux ARM users need a source build via
+  `cmake-js`. `codehub doctor` now hard-fails on missing binding (was
+  warn-and-continue in the auto-probe era).
+- **lbug's 8 TiB virtual mmap per Database can exhaust the 47-bit user
+  virtual address space on 64-bit Linux** when many test pools open
+  concurrently — surfaces as `Buffer manager exception: Mmap for size
+  8796093022208 failed`. Wave 1 chased this in detail and confirmed
+  with a probe: lbug's `maxDBSize` defaults to `1 << 43` and the
+  request is reserved at `Database` construction (not lazy).
+  `bufferManagerSize` defaults to `min(systemMem, maxDBSize) * 0.8`.
+  The pool now passes both as explicit constructor args
+  (16 GiB `maxDbBytes`, 2 GiB `bufferManagerBytes`) so concurrent
+  Databases do not exhaust VA. See
+  [`solutions/conventions/lbug-copy-from-subquery-bulk-load.md`](../../.erpaval/solutions/conventions/lbug-copy-from-subquery-bulk-load.md)
+  for the citations (kuzudb/kuzu#1826, the upstream Database constructor,
+  `BufferPoolConstants::DEFAULT_VM_REGION_MAX_SIZE`).
+- **Sentinel STRING[] columns must be non-empty in lbug bulk-load.**
+  An empty-array sentinel (`[]`) makes lbug's struct-field type
+  inference resolve to `LIST(ANY)`, and any later data row with a
+  string then throws "Trying to create a vector with ANY type". The
+  fix is `["__sentinel__"]`; the seed value is filtered before COPY by
+  the existing `WITH r WHERE r.id <> SENTINEL`.
+- **lbug rejects writes against a Database opened with `readOnly=true`,
+  including `CALL CREATE_FTS_INDEX(...)` and `CALL CREATE_VECTOR_INDEX(...)`.**
+  These are now built at the end of `bulkLoad` (write phase). The
+  `ensureFtsIndex` / `ensureVectorIndex` lazy helpers no-op in
+  readOnly mode; readers query the existing index built by the most
+  recent write.
+
+## Future work
+
+The user's "maybe sqlite-wasm for temporal" comment is captured here as
+forward-work: replacing `DuckDbStore` with a JS-only `ITemporalStore`
+implementor (e.g. `sql.js`, `wa-sqlite`) would drop the last native
+binding from the temporal tier and let OCH ship as pure-JS at the
+distributed-boundary. The interface contract — `exec(sql, params)`,
+`bulkLoadCochanges`, `lookupCochangesForFile`, `bulkLoadSymbolSummaries`,
+`exportEmbeddingsToParquet` — is small enough to port; only the
+deterministic Parquet writer would need investigation (sql.js does not
+ship a `COPY ... TO PARQUET` analog out of the box). Not in scope for
+this ADR.
+
+## Numbers
+
+Net diff for this rip: ~5,800 deletions, ~150 insertions. Workspace
+test count after: 1931 passing, 0 failing, 2 skipped (one platform-
+gated lbug vector probe + one platform-gated embedder probe). Storage
+package: 148/0/1 over three consecutive runs — no flake.
diff --git a/packages/analysis/src/test-utils.ts b/packages/analysis/src/test-utils.ts
index ca04f74c..209b51a5 100644
--- a/packages/analysis/src/test-utils.ts
+++ b/packages/analysis/src/test-utils.ts
@@ -150,7 +150,7 @@ function sortEdges(edges: readonly FakeEdge[]): FakeEdge[] {
  * code under test.
  */
 export class FakeStore implements IGraphStore {
-  readonly dialect: GraphDialect = "none";
+  readonly dialect: GraphDialect = "cypher";
   readonly nodes: FakeNode[] = [];
   readonly edges: FakeEdge[] = [];
 
diff --git a/packages/cli/src/commands/analyze-carry-forward.test.ts b/packages/cli/src/commands/analyze-carry-forward.test.ts
index ac970641..cd2657d8 100644
--- a/packages/cli/src/commands/analyze-carry-forward.test.ts
+++ b/packages/cli/src/commands/analyze-carry-forward.test.ts
@@ -35,7 +35,7 @@ import {
   KnowledgeGraph,
   type NodeId,
 } from "@opencodehub/core-types";
-import { DuckDbStore, resolveDbPath, resolveRepoMetaDir } from "@opencodehub/storage";
+import { openStore, resolveGraphPath, resolveRepoMetaDir } from "@opencodehub/storage";
 import { loadPreviousGraph } from "./analyze.js";
 
 /**
@@ -164,11 +164,12 @@ async function seedPriorIndex(repoPath: string): Promise<{
   });
 
   await mkdir(resolveRepoMetaDir(repoPath), { recursive: true });
-  const store = new DuckDbStore(resolveDbPath(repoPath));
+  const store = await openStore({ path: resolveGraphPath(repoPath) });
   try {
-    await store.open();
-    await store.createSchema();
-    await store.bulkLoad(graph);
+    await store.graph.open();
+    await store.temporal.open();
+    await store.graph.createSchema();
+    await store.graph.bulkLoad(graph);
   } finally {
     await store.close();
   }
diff --git a/packages/cli/src/commands/analyze.ts b/packages/cli/src/commands/analyze.ts
index 1a7976b4..9c9cf3a4 100644
--- a/packages/cli/src/commands/analyze.ts
+++ b/packages/cli/src/commands/analyze.ts
@@ -33,8 +33,9 @@ import {
 } from "@opencodehub/core-types";
 import { pipeline } from "@opencodehub/ingestion";
 import {
+  type BulkLoadProgressEvent,
   openStore,
-  resolveDbPath,
+  resolveGraphPath,
   resolveRepoMetaDir,
   type Store,
   writeStoreMeta,
@@ -291,6 +292,11 @@ export async function runAnalyze(path: string, opts: AnalyzeOptions = {}): Promi
       ? { embeddingHashCacheAdapter: embeddingHashAdapter.adapter }
       : {}),
     ...(incrementalFrom !== undefined ? { incrementalFrom } : {}),
+    // Phase progress: one line per phase end. Filtered to the long poles so
+    // the operator sees motion without `--verbose`-level chatter — sub-100ms
+    // phases stay quiet because they fire too fast to matter for "is this
+    // still running?" feedback.
+    onProgress: makePhaseProgressReporter(),
   };
   let result: Awaited<ReturnType<typeof pipeline.runIngestion>>;
   try {
@@ -302,20 +308,19 @@ export async function runAnalyze(path: string, opts: AnalyzeOptions = {}): Promi
 
   logWarnings(result.warnings, opts.verbose === true);
 
-  // Persist to the composed graph + temporal store. Backend resolution is
-  // env-driven (`CODEHUB_STORE`); the default `"duck"` writes to
-  // `<repo>/.codehub/graph.duckdb` exactly like the legacy path. The
-  // temporal-tier writes (`bulkLoadCochanges`, `bulkLoadSymbolSummaries`)
-  // route through `store.temporal`.
+  // Persist to the composed graph + temporal store. Storage is always
+  // graph.lbug (graph-tier) + temporal.duckdb sidecar (cochanges, summary
+  // cache); the temporal-tier writes (`bulkLoadCochanges`,
+  // `bulkLoadSymbolSummaries`) route through `store.temporal`.
   await mkdir(resolveRepoMetaDir(repoPath), { recursive: true });
-  const dbPath = resolveDbPath(repoPath);
-  const store: Store = await openStore({ path: dbPath, backend: "auto" });
+  const dbPath = resolveGraphPath(repoPath);
+  const store: Store = await openStore({ path: dbPath });
   try {
     await store.graph.open();
-    if (store.graphFile !== store.temporalFile) await store.temporal.open();
+    await store.temporal.open();
     await store.graph.createSchema();
-    if (store.graphFile !== store.temporalFile) await store.temporal.createSchema();
-    await store.graph.bulkLoad(result.graph);
+    await store.temporal.createSchema();
+    await store.graph.bulkLoad(result.graph, { onProgress: makeBulkLoadReporter("graph") });
     // Persist cochange rows to the dedicated `cochanges` table. `bulkLoad` in
     // replace mode already truncated it, but `bulkLoadCochanges` does its own
     // DELETE inside the same transaction so the call is idempotent even on
@@ -521,8 +526,8 @@ export async function loadPreviousGraph(
 ): Promise<pipeline.PreviousGraph | undefined> {
   const scanState = await readScanState(repoPath);
   if (scanState === undefined) return undefined;
-  const dbPath = resolveDbPath(repoPath);
-  const store = await openStore({ path: dbPath, backend: "auto" }).catch(() => undefined);
+  const dbPath = resolveGraphPath(repoPath);
+  const store = await openStore({ path: dbPath }).catch(() => undefined);
   if (store === undefined) return undefined;
   try {
     await store.graph.open();
@@ -734,10 +739,8 @@ export async function resolveMaxSummariesCap(
  * back to the first-run heuristic.
  */
 async function countPriorCallableSymbols(repoPath: string): Promise<number | undefined> {
-  const dbPath = resolveDbPath(repoPath);
-  const store = await openStore({ path: dbPath, backend: "auto", readOnly: true }).catch(
-    () => undefined,
-  );
+  const dbPath = resolveGraphPath(repoPath);
+  const store = await openStore({ path: dbPath, readOnly: true }).catch(() => undefined);
   if (store === undefined) return undefined;
   try {
     await store.graph.open();
@@ -771,17 +774,14 @@ async function countPriorCallableSymbols(repoPath: string): Promise<number | und
 async function openSummaryCacheAdapter(
   repoPath: string,
 ): Promise<{ adapter: pipeline.SummaryCacheAdapter; close: () => Promise<void> } | undefined> {
-  const dbPath = resolveDbPath(repoPath);
-  const store = await openStore({ path: dbPath, backend: "auto", readOnly: true }).catch(
-    () => undefined,
-  );
+  const dbPath = resolveGraphPath(repoPath);
+  const store = await openStore({ path: dbPath, readOnly: true }).catch(() => undefined);
   if (store === undefined) return undefined;
   try {
     // The summary cache lives on the temporal tier. Open both views so
-    // the close() symmetry holds; on the duck backend the second open
-    // is a no-op against the same connection.
+    // the close() symmetry holds.
     await store.graph.open();
-    if (store.graphFile !== store.temporalFile) await store.temporal.open();
+    await store.temporal.open();
   } catch {
     await store.close().catch(() => {});
     return undefined;
@@ -811,10 +811,8 @@ async function openEmbeddingHashCacheAdapter(
 ): Promise<
   { adapter: pipeline.EmbeddingHashCacheAdapter; close: () => Promise<void> } | undefined
 > {
-  const dbPath = resolveDbPath(repoPath);
-  const store = await openStore({ path: dbPath, backend: "auto", readOnly: true }).catch(
-    () => undefined,
-  );
+  const dbPath = resolveGraphPath(repoPath);
+  const store = await openStore({ path: dbPath, readOnly: true }).catch(() => undefined);
   if (store === undefined) return undefined;
   try {
     await store.graph.open();
@@ -1393,3 +1391,94 @@ function log(message: string): void {
   // subcommands like `sql` and `query --json`.
   console.warn(message);
 }
+
+/**
+ * One-line phase-end reporter. Surfaces a `phase=name dur=ms` line for every
+ * phase as it completes so the operator can see motion through the ingestion
+ * pipeline. We intentionally skip "start" events (would double the line
+ * count for no extra information) and silence sub-100ms phases (too fast
+ * to matter as a "still running?" signal — they fire as a burst at the end
+ * of an analyze and would just be noise).
+ *
+ * Errors and warnings already flow through `result.warnings` post-run, so
+ * this reporter ignores `kind: "warn" | "error"` events.
+ */
+function makePhaseProgressReporter(): (ev: pipeline.ProgressEvent) => void {
+  return (ev) => {
+    if (ev.kind !== "end") return;
+    const dur = ev.elapsedMs;
+    if (dur === undefined || dur < 100) return;
+    log(`codehub analyze: phase ${ev.phase} ${formatDuration(dur)}`);
+  };
+}
+
+/**
+ * Bulk-load progress reporter. The graph-db backend's UNWIND-batched
+ * insert path emits per-batch events; we collapse the batch chatter into
+ * a stage-level summary (start/end of nodes; start/end of edges; one line
+ * per relation kind) so the output stays scannable on a long-running
+ * analyze. The `tag` distinguishes graph vs temporal-tier bulk-loads in
+ * the rare deployment that runs both.
+ */
+function makeBulkLoadReporter(tag: string): (ev: BulkLoadProgressEvent) => void {
+  let lastNodesPct = -1;
+  return (ev) => {
+    switch (ev.kind) {
+      case "truncate-start":
+        log(`codehub analyze: ${tag} bulk-load — truncating prior rows`);
+        break;
+      case "nodes-start":
+        log(`codehub analyze: ${tag} bulk-load — inserting ${ev.total ?? "?"} nodes`);
+        lastNodesPct = -1;
+        break;
+      case "nodes-batch": {
+        // Throttle: only print when we cross a 25% bucket so a 22k-node
+        // run produces ~3 progress lines, not 22.
+        const total = ev.total ?? 0;
+        const done = ev.done ?? 0;
+        if (total === 0) return;
+        const pct = Math.floor((done / total) * 4) * 25;
+        if (pct === lastNodesPct || pct >= 100) return;
+        lastNodesPct = pct;
+        log(
+          `codehub analyze: ${tag} bulk-load — nodes ${done}/${total} (${pct}%) ` +
+            `${formatDuration(ev.elapsedMs ?? 0)}`,
+        );
+        break;
+      }
+      case "nodes-end":
+        log(
+          `codehub analyze: ${tag} bulk-load — ${ev.done ?? "?"} nodes inserted ` +
+            `${formatDuration(ev.elapsedMs ?? 0)}`,
+        );
+        break;
+      case "edges-start":
+        log(`codehub analyze: ${tag} bulk-load — inserting ${ev.total ?? "?"} edges`);
+        break;
+      case "edges-batch":
+        // One line per relation kind once its bucket finishes — gives the
+        // operator a sense of which rel types dominate the wall clock.
+        if (ev.relType !== undefined) {
+          log(
+            `codehub analyze: ${tag} bulk-load — edges ${ev.done ?? "?"}/${ev.total ?? "?"} ` +
+              `[${ev.relType}] ${formatDuration(ev.elapsedMs ?? 0)}`,
+          );
+        }
+        break;
+      case "edges-end":
+        log(
+          `codehub analyze: ${tag} bulk-load — ${ev.done ?? "?"} edges inserted ` +
+            `${formatDuration(ev.elapsedMs ?? 0)}`,
+        );
+        break;
+      // truncate-end is silent — paired with the start line above.
+      default:
+        break;
+    }
+  };
+}
+
+function formatDuration(ms: number): string {
+  if (ms < 1000) return `(${Math.round(ms)} ms)`;
+  return `(${(ms / 1000).toFixed(1)} s)`;
+}
diff --git a/packages/cli/src/commands/augment.test.ts b/packages/cli/src/commands/augment.test.ts
index 450558bf..77ded290 100644
--- a/packages/cli/src/commands/augment.test.ts
+++ b/packages/cli/src/commands/augment.test.ts
@@ -23,7 +23,7 @@ import {
   type NodeId,
   type ProcessNode,
 } from "@opencodehub/core-types";
-import { DuckDbStore, resolveDbPath } from "@opencodehub/storage";
+import { openStore, resolveGraphPath } from "@opencodehub/storage";
 import { upsertRegistry } from "../registry.js";
 import { augment, runAugment } from "./augment.js";
 
@@ -40,12 +40,13 @@ async function seedRepoWithStore(
   await mkdir(join(repoPath, ".codehub"), { recursive: true });
   const g = new KnowledgeGraph();
   build(g);
-  const dbPath = resolveDbPath(repoPath);
-  const store = new DuckDbStore(dbPath);
+  const dbPath = resolveGraphPath(repoPath);
+  const store = await openStore({ path: dbPath });
   try {
-    await store.open();
-    await store.createSchema();
-    await store.bulkLoad(g);
+    await store.graph.open();
+    await store.temporal.open();
+    await store.graph.createSchema();
+    await store.graph.bulkLoad(g);
   } finally {
     await store.close();
   }
diff --git a/packages/cli/src/commands/augment.ts b/packages/cli/src/commands/augment.ts
index c3512304..9c67d5a3 100644
--- a/packages/cli/src/commands/augment.ts
+++ b/packages/cli/src/commands/augment.ts
@@ -23,7 +23,7 @@
 
 import { resolve, sep } from "node:path";
 import { bm25Search } from "@opencodehub/search";
-import { type IGraphStore, openStore, resolveDbPath } from "@opencodehub/storage";
+import { type IGraphStore, openStore, resolveGraphPath } from "@opencodehub/storage";
 import { type RepoEntry, readRegistry } from "../registry.js";
 
 /** Public-API shape for `runAugment`. */
@@ -91,10 +91,8 @@ export async function augment(pattern: string, opts: AugmentOptions = {}): Promi
   const repo = await resolveRepoForCwd(cwd, opts.home);
   if (repo === undefined) return "";
 
-  const dbPath = resolveDbPath(repo.path);
-  const composed = await openStore({ path: dbPath, backend: "auto", readOnly: true }).catch(
-    () => undefined,
-  );
+  const dbPath = resolveGraphPath(repo.path);
+  const composed = await openStore({ path: dbPath, readOnly: true }).catch(() => undefined);
   if (composed === undefined) return "";
   try {
     await composed.graph.open();
diff --git a/packages/cli/src/commands/code-pack.ts b/packages/cli/src/commands/code-pack.ts
index 3676ab4f..6a3b4aff 100644
--- a/packages/cli/src/commands/code-pack.ts
+++ b/packages/cli/src/commands/code-pack.ts
@@ -39,7 +39,7 @@ import { mkdir, mkdtemp, readFile, rename, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { generatePack, type PackManifest } from "@opencodehub/pack";
-import { type IGraphStore, openStore, resolveDbPath, type Store } from "@opencodehub/storage";
+import { type IGraphStore, openStore, resolveGraphPath, type Store } from "@opencodehub/storage";
 import { runPack } from "./pack.js";
 
 /** Default token budget when `--budget` is omitted. */
@@ -123,20 +123,14 @@ async function runPackEngine(repoPath: string, args: CodePackArgs): Promise<Code
   const tokenizer = args.tokenizer ?? DEFAULT_TOKENIZER_ID;
   const generate = args._generatePack ?? generatePack;
 
-  // Production: open a read-only graph store via the backend-agnostic
-  // factory; tests inject `_store` to skip the native binding entirely.
-  const dbPath = resolveDbPath(repoPath);
-  if (args._store === undefined) {
-    // The store factory accepts a `graph.duckdb` path and rewrites it to
-    // the lbug sibling when the backend resolves to lbug. Check both so
-    // the error surfaces only when neither artifact is on disk.
-    const lbugPath = resolve(repoPath, ".codehub", "graph.lbug");
-    if (!existsSync(dbPath) && !existsSync(lbugPath)) {
-      throw new Error(
-        `codehub code-pack: no graph index at ${dbPath} or ${lbugPath}. ` +
-          "Run `codehub analyze` first to populate the store.",
-      );
-    }
+  // Production: open a read-only graph store; tests inject `_store` to
+  // skip the native binding entirely.
+  const dbPath = resolveGraphPath(repoPath);
+  if (args._store === undefined && !existsSync(dbPath)) {
+    throw new Error(
+      `codehub code-pack: no graph index at ${dbPath}. ` +
+        "Run `codehub analyze` first to populate the store.",
+    );
   }
   const ownsStore = args._store === undefined;
   // Composed-store envelope used only when this command owns lifecycle.
@@ -144,18 +138,14 @@ async function runPackEngine(repoPath: string, args: CodePackArgs): Promise<Code
   // deterministic order without re-running the factory.
   const owned = ownsStore
     ? await (async () => {
-        const composed = await openStore({ path: dbPath, backend: "auto", readOnly: true });
+        const composed = await openStore({ path: dbPath, readOnly: true });
         await composed.graph.open();
         return composed;
       })()
     : undefined;
-  // generatePack consumes `Store` (= `OpenStoreResult`) so the
-  // embeddings sidecar can dispatch on `store.backend`. Tests
-  // historically passed an `IGraphStore` stub via `_store`; route that
-  // through the `internal.graphOnly` seam which auto-wraps it into a
-  // no-op-temporal Store with `backend: "duck"` (the sidecar then
-  // resolves to absent unless the stub duck-types
-  // `exportEmbeddingsParquet` itself).
+  // generatePack consumes `Store` (= `OpenStoreResult`). Tests historically
+  // passed an `IGraphStore` stub via `_store`; route that through the
+  // `internal.graphOnly` seam which auto-wraps it into a no-op-temporal Store.
   const composedStore: Store | undefined = isStoreShape(args._store)
     ? args._store
     : (owned ?? undefined);
diff --git a/packages/cli/src/commands/context.test.ts b/packages/cli/src/commands/context.test.ts
index e656e363..bd08a02e 100644
--- a/packages/cli/src/commands/context.test.ts
+++ b/packages/cli/src/commands/context.test.ts
@@ -98,7 +98,6 @@ function makeFakeStore(opts: FakeStoreOptions = {}): FakeStoreHandle {
   };
 
   const composed: Store = {
-    backend: "duck",
     graph: graph as unknown as IGraphStore,
     temporal: {} as unknown as ITemporalStore,
     graphFile: "/tmp/fake.duckdb",
diff --git a/packages/cli/src/commands/group.ts b/packages/cli/src/commands/group.ts
index 999b0015..ada2896d 100644
--- a/packages/cli/src/commands/group.ts
+++ b/packages/cli/src/commands/group.ts
@@ -28,7 +28,7 @@ import type { ContractRegistry, SyncRepoInput } from "@opencodehub/analysis";
 import { runGroupSync } from "@opencodehub/analysis";
 import { DEFAULT_RRF_K, DEFAULT_RRF_TOP_K, rrf } from "@opencodehub/search";
 import type { SearchResult } from "@opencodehub/storage";
-import { openStore, readStoreMeta, resolveDbPath } from "@opencodehub/storage";
+import { openStore, readStoreMeta, resolveGraphPath } from "@opencodehub/storage";
 import { Command } from "commander";
 import { writeFileAtomic } from "../fs-atomic.js";
 import {
@@ -425,8 +425,8 @@ export async function runGroupQuery(
       continue;
     }
     const repoPath = resolve(registryHit.path);
-    const dbPath = resolveDbPath(repoPath);
-    const composed = await openStore({ path: dbPath, backend: "auto", readOnly: true });
+    const dbPath = resolveGraphPath(repoPath);
+    const composed = await openStore({ path: dbPath, readOnly: true });
     try {
       await composed.graph.open();
       const results = await composed.graph.search({ text, limit: 50 });
diff --git a/packages/cli/src/commands/ingest-sarif.ts b/packages/cli/src/commands/ingest-sarif.ts
index bcede37d..4cbabef8 100644
--- a/packages/cli/src/commands/ingest-sarif.ts
+++ b/packages/cli/src/commands/ingest-sarif.ts
@@ -36,7 +36,7 @@ import {
 import {
   type IGraphStore,
   openStore,
-  resolveDbPath,
+  resolveGraphPath,
   resolveRepoMetaDir,
 } from "@opencodehub/storage";
 import { readRegistry } from "../registry.js";
@@ -96,8 +96,8 @@ export async function runIngestSarif(
     log = applyBaselineState(log, baselineLog);
   }
 
-  const dbPath = resolveDbPath(repoPath);
-  const composed = await openStore({ path: dbPath, backend: "auto" });
+  const dbPath = resolveGraphPath(repoPath);
+  const composed = await openStore({ path: dbPath });
   let graph: KnowledgeGraph;
   let summary: BuildSummary;
   try {
diff --git a/packages/cli/src/commands/open-store.ts b/packages/cli/src/commands/open-store.ts
index 74c8a8fb..6975dca5 100644
--- a/packages/cli/src/commands/open-store.ts
+++ b/packages/cli/src/commands/open-store.ts
@@ -6,20 +6,19 @@
  * Returns the canonical {@link Store} envelope from `@opencodehub/storage`
  * so callers can route graph-tier queries through `store.graph` and
  * temporal-tier queries (cochanges, summaries, `--sql` escape hatch)
- * through `store.temporal`. Backend selection follows the standard
- * `openStore` resolution (env-driven `CODEHUB_STORE`, with auto-detect
- * when unset).
+ * through `store.temporal`. Storage is always graph.lbug + temporal.duckdb;
+ * the legacy backend selector was removed when the DuckDB graph backend
+ * was ripped out (see ADR 0016).
  */
 
 import { resolve } from "node:path";
-import { openStore, resolveDbPath, type Store } from "@opencodehub/storage";
+import { openStore, resolveGraphPath, type Store } from "@opencodehub/storage";
 import { readRegistry } from "../registry.js";
 
 export interface OpenStoreOptions {
   readonly repo?: string;
   readonly home?: string;
   readonly readOnly?: boolean;
-  readonly backend?: "auto" | "duck" | "lbug";
 }
 
 export interface OpenStoreResult {
@@ -29,10 +28,9 @@ export interface OpenStoreResult {
 
 export async function openStoreForCommand(opts: OpenStoreOptions): Promise<OpenStoreResult> {
   const repoPath = await resolveRepoPath(opts);
-  const dbPath = resolveDbPath(repoPath);
+  const dbPath = resolveGraphPath(repoPath);
   const store = await openStore({
     path: dbPath,
-    backend: opts.backend ?? "auto",
     readOnly: opts.readOnly ?? true,
   });
   // The legacy CLI entry point opened the DuckDB connection eagerly and
@@ -41,9 +39,7 @@ export async function openStoreForCommand(opts: OpenStoreOptions): Promise<OpenS
   // that contract by opening both views here so command handlers stay a
   // simple try/finally pair around the work.
   await store.graph.open();
-  if (store.graphFile !== store.temporalFile) {
-    await store.temporal.open();
-  }
+  await store.temporal.open();
   return { repoPath, store };
 }
 
diff --git a/packages/cli/src/commands/query.test.ts b/packages/cli/src/commands/query.test.ts
index dba412e0..4a3b169b 100644
--- a/packages/cli/src/commands/query.test.ts
+++ b/packages/cli/src/commands/query.test.ts
@@ -139,7 +139,6 @@ function makeFakeStore(opts: FakeStoreOptions = {}): FakeStoreHandle {
       : {};
 
   const composed: Store = {
-    backend: "duck",
     graph: graph as unknown as IGraphStore,
     temporal: temporal as unknown as ITemporalStore,
     graphFile: "/tmp/fake.duckdb",
diff --git a/packages/cli/src/commands/scan.ts b/packages/cli/src/commands/scan.ts
index 7027331b..a31c7a42 100644
--- a/packages/cli/src/commands/scan.ts
+++ b/packages/cli/src/commands/scan.ts
@@ -50,7 +50,7 @@ import {
   type ScannerStatus,
   SPECTRAL_SPEC,
 } from "@opencodehub/scanners";
-import { openStore, resolveDbPath, resolveRepoMetaDir } from "@opencodehub/storage";
+import { openStore, resolveGraphPath, resolveRepoMetaDir } from "@opencodehub/storage";
 import { readRegistry } from "../registry.js";
 import { runIngestSarif } from "./ingest-sarif.js";
 
@@ -266,9 +266,9 @@ function applySuppressionsForRepo(repoPath: string, log: SarifLog): SarifLog {
  * subset.
  */
 export async function readProjectProfile(repoPath: string): Promise<ProjectProfileGate> {
-  const dbPath = resolveDbPath(repoPath);
+  const dbPath = resolveGraphPath(repoPath);
   try {
-    const composed = await openStore({ path: dbPath, backend: "auto", readOnly: true });
+    const composed = await openStore({ path: dbPath, readOnly: true });
     try {
       await composed.graph.open();
       // The single-row ProjectProfile lookup. `listNodesByKind` materializes
diff --git a/packages/cli/src/lib/is-indexed.ts b/packages/cli/src/lib/is-indexed.ts
index 292c5cd2..19b8ac6c 100644
--- a/packages/cli/src/lib/is-indexed.ts
+++ b/packages/cli/src/lib/is-indexed.ts
@@ -1,35 +1,21 @@
 /**
- * Backend-aware check for whether a repo has been indexed by `codehub
- * analyze`. Replaces hard-coded `existsSync('.codehub/graph.duckdb')` probes
- * that pre-date the M3 graph-db backend split.
+ * Check whether a repo has been indexed by `codehub analyze`. Truthy when
+ * either signal exists under `<repoPath>/.codehub`:
  *
- * Truthy when ANY of the following exist under `<repoPath>/.codehub`:
- *   - `meta.json` — written by every backend after a successful analyze
- *     (preferred signal — explicit and backend-agnostic).
- *   - The `graphFile` for any in-tree backend (currently `duck` →
- *     `graph.duckdb`, `lbug` → `graph.lbug`). Filenames come from the
- *     storage `describeArtifacts` helper so two-store deployments share a
- *     single source of truth.
+ *   - `meta.json` — written by every successful analyze run.
+ *   - `graph.lbug` — the lbug graph artifact (post-M7 the only graph backend).
  *
- * Returns a plain boolean — UI surfaces (e.g. `codehub list`) want to
- * render a single column without leaking which backend produced the
- * index. Pair with the typed labels in `is-indexed.label` if you need
- * the specific backend; today every consumer just needs the boolean.
+ * Returns a plain boolean — UI surfaces (e.g. `codehub list`) want a single
+ * column rendering.
  */
 
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { describeArtifacts } from "@opencodehub/storage";
 
-/** Backends whose artifacts the `codehub` CLI knows how to produce in-tree. */
-const IN_TREE_BACKENDS = ["duck", "lbug"] as const;
-
 export function codehubIsIndexed(repoPath: string): boolean {
   const codehubDir = join(repoPath, ".codehub");
   if (existsSync(join(codehubDir, "meta.json"))) return true;
-  for (const backend of IN_TREE_BACKENDS) {
-    const { graphFile } = describeArtifacts(backend);
-    if (existsSync(join(codehubDir, graphFile))) return true;
-  }
-  return false;
+  const { graphFile } = describeArtifacts();
+  return existsSync(join(codehubDir, graphFile));
 }
diff --git a/packages/mcp/src/connection-pool.test.ts b/packages/mcp/src/connection-pool.test.ts
index 0871fe12..daa890e1 100644
--- a/packages/mcp/src/connection-pool.test.ts
+++ b/packages/mcp/src/connection-pool.test.ts
@@ -17,7 +17,6 @@ function makeFakeStore(path: string): {
   let closeCalls = 0;
   const store = {
     path,
-    backend: "duck" as const,
     close: async () => {
       closeCalls += 1;
       closed = true;
diff --git a/packages/mcp/src/connection-pool.ts b/packages/mcp/src/connection-pool.ts
index 6e7ca026..be175580 100644
--- a/packages/mcp/src/connection-pool.ts
+++ b/packages/mcp/src/connection-pool.ts
@@ -20,12 +20,11 @@
  * `shutdown()` drains the pool on stdio close so the server exits cleanly.
  *
  * The pool caches the composed `OpenStoreResult` so MCP tools can route
- * graph-tier calls through `store.graph` and temporal-tier calls
- * (cochanges, summaries, `--sql` escape hatch) through `store.temporal`.
- * Backend selection follows the standard `openStore` resolution (env-
- * driven `CODEHUB_STORE`, with auto-detect when unset).
- * `OpenStoreResult.close()` is the deterministic composite close — for
- * the DuckDB-only deployment that's a single underlying close.
+ * graph-tier calls through `store.graph` (lbug at `<repo>/.codehub/graph.lbug`)
+ * and temporal-tier calls (cochanges, summaries, `--sql` escape hatch)
+ * through `store.temporal` (DuckDB at `<repo>/.codehub/temporal.duckdb`).
+ * `OpenStoreResult.close()` is the deterministic composite close — graph
+ * first, then temporal.
  */
 
 import { openStore, type Store } from "@opencodehub/storage";
@@ -49,24 +48,20 @@ const DEFAULT_TTL_MS = 15 * 60 * 1000;
 
 /**
  * Factory indirection keeps tests mockable without standing up the
- * underlying database. Production always calls `openStore` so backend
- * selection (DuckDB or the graph-db pairing) follows the env-driven
- * resolution.
+ * underlying database. Production always calls `openStore`, which
+ * composes the lbug graph view and the DuckDB temporal view from the
+ * `<repo>/.codehub/` parent directory.
  */
 export type StoreFactory = (dbPath: string) => Promise<Store>;
 
 const defaultFactory: StoreFactory = async (dbPath) => {
-  // openStore picks backend via CODEHUB_STORE (defaults to "duck"). We
-  // open read-only because every MCP tool is a reader; the ingestion
-  // pipeline owns writes and runs out-of-process.
+  // openStore composes graph (lbug) + temporal (DuckDB) views from the
+  // shared `<repo>/.codehub/` parent. We open read-only because every
+  // MCP tool is a reader; the ingestion pipeline owns writes and runs
+  // out-of-process.
   const store = await openStore({ path: dbPath, readOnly: true });
   await store.graph.open();
-  if (store.graphFile !== store.temporalFile) {
-    // Two distinct underlying files — open each side. For the default
-    // DuckDB backend graph and temporal alias the same instance and the
-    // second open() is a no-op.
-    await store.temporal.open();
-  }
+  await store.temporal.open();
   return store;
 };
 
diff --git a/packages/mcp/src/repo-resolver.ts b/packages/mcp/src/repo-resolver.ts
index 7027c3ff..85e2c149 100644
--- a/packages/mcp/src/repo-resolver.ts
+++ b/packages/mcp/src/repo-resolver.ts
@@ -17,7 +17,7 @@ import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import {
   readStoreMeta,
-  resolveDbPath,
+  resolveGraphPath,
   resolveRegistryPath,
   type StoreMeta,
 } from "@opencodehub/storage";
@@ -155,7 +155,7 @@ export async function resolveRepo(
   }
 
   const repoPath = resolve(entry.path);
-  const dbPath = resolveDbPath(repoPath);
+  const dbPath = resolveGraphPath(repoPath);
 
   let meta: StoreMeta | undefined;
   if (!opts.skipMeta) {
diff --git a/packages/mcp/src/repo-uri-for-entry.ts b/packages/mcp/src/repo-uri-for-entry.ts
index 96f93bfa..0798b067 100644
--- a/packages/mcp/src/repo-uri-for-entry.ts
+++ b/packages/mcp/src/repo-uri-for-entry.ts
@@ -18,7 +18,7 @@
 import { resolve } from "node:path";
 import { makeNodeId } from "@opencodehub/core-types";
 import type { IGraphStore } from "@opencodehub/storage";
-import { resolveDbPath } from "@opencodehub/storage";
+import { resolveGraphPath } from "@opencodehub/storage";
 import type { ConnectionPool } from "./connection-pool.js";
 import { deriveRepoUri, type RegistryEntry } from "./repo-resolver.js";
 
@@ -47,7 +47,7 @@ export async function repoUriForEntry(
 ): Promise<string> {
   if (pool !== undefined) {
     const repoPath = resolve(entry.path);
-    const dbPath = resolveDbPath(repoPath);
+    const dbPath = resolveGraphPath(repoPath);
     try {
       const store = await pool.acquire(repoPath, dbPath);
       try {
diff --git a/packages/mcp/src/test-utils.ts b/packages/mcp/src/test-utils.ts
index 8a60d87b..6baed83c 100644
--- a/packages/mcp/src/test-utils.ts
+++ b/packages/mcp/src/test-utils.ts
@@ -13,7 +13,7 @@
  *
  * The module is intentionally tolerant: every typed finder has a sane
  * default that filters the seeded arrays exactly the way the real
- * `DuckDbStore` does. Tests can override a single finder via the
+ * graph-backed adapter does. Tests can override a single finder via the
  * `overrides` parameter when they need bespoke behaviour (e.g. cochanges,
  * BM25 search, traversal).
  */
@@ -40,7 +40,6 @@ import type {
   BulkLoadStats,
   ConsumerProducerEdge,
   DescendantTraversalOptions,
-  DuckDbStore,
   EmbeddingRow,
   IGraphStore,
   ITemporalStore,
@@ -70,17 +69,16 @@ import { ConnectionPool } from "./connection-pool.js";
 
 /**
  * Wrap an in-memory IGraphStore-shaped fake as the composed `Store`
- * (`OpenStoreResult`) that the connection pool returns. The same
- * instance backs both `graph` and `temporal` because DuckDbStore
- * implements both interfaces over a single connection in production.
+ * (`OpenStoreResult`) that the connection pool returns. The same fake
+ * instance backs both `graph` and `temporal` views — tests don't care
+ * about the production split between lbug graph + DuckDB temporal.
  */
 export function wrapAsStore(fake: unknown): Store {
   return {
-    backend: "duck" as const,
     graph: fake as IGraphStore,
     temporal: fake as ITemporalStore,
-    graphFile: "/in-memory/graph.duckdb",
-    temporalFile: "/in-memory/graph.duckdb",
+    graphFile: "/in-memory/graph.lbug",
+    temporalFile: "/in-memory/temporal.duckdb",
     close: async () => {
       const closer = (fake as { close?: () => Promise<void> }).close;
       if (typeof closer === "function") await closer.call(fake);
@@ -328,13 +326,13 @@ function applyLikeFilter(value: string, pattern: string): boolean {
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
-// makeFakeGraphStore — the typed-finder-shaped DuckDbStore fake.
+// makeFakeGraphStore — the typed-finder-shaped IGraphStore fake.
 // ─────────────────────────────────────────────────────────────────────────────
 
 export function makeFakeGraphStore(
   data: FakeData = {},
   overrides: StoreOverrides = {},
-): DuckDbStore {
+): IGraphStore {
   const nodes = data.nodes ?? [];
   const edges = data.edges ?? [];
   const findings = data.findings ?? [];
@@ -610,7 +608,7 @@ export function makeFakeGraphStore(
     defaults[key] = value;
   }
 
-  return defaults as unknown as DuckDbStore;
+  return defaults as unknown as IGraphStore;
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -637,7 +635,7 @@ export interface McpHarness {
 export interface MakeHarnessOptions {
   readonly repoName?: string;
   readonly registry?: Readonly<Record<string, FakeRegistryEntry>>;
-  readonly storeFactory: () => DuckDbStore | Promise<DuckDbStore>;
+  readonly storeFactory: () => IGraphStore | Promise<IGraphStore>;
   readonly serverCapabilities?: { tools?: object; resources?: object };
   readonly tmpPrefix?: string;
 }
diff --git a/packages/mcp/src/tools/group-contracts.ts b/packages/mcp/src/tools/group-contracts.ts
index 16e847ce..4a5acba5 100644
--- a/packages/mcp/src/tools/group-contracts.ts
+++ b/packages/mcp/src/tools/group-contracts.ts
@@ -22,7 +22,7 @@ import { resolve } from "node:path";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { ContractRegistry } from "@opencodehub/analysis";
 import type { IGraphStore } from "@opencodehub/storage";
-import { resolveDbPath } from "@opencodehub/storage";
+import { resolveGraphPath } from "@opencodehub/storage";
 import { z } from "zod";
 import { toolError, toolErrorFromUnknown } from "../error-envelope.js";
 import { readGroup } from "../group-resolver.js";
@@ -153,10 +153,10 @@ export async function runGroupContracts(
       }
       repoUriByName.set(repo.name, await repoUriForEntry(hit, ctx.pool));
       const repoPath = resolve(hit.path);
-      const dbPath = resolveDbPath(repoPath);
+      const dbPath = resolveGraphPath(repoPath);
       const store = await ctx.pool.acquire(repoPath, dbPath).catch((err: unknown) => {
         const msg = err instanceof Error ? err.message : String(err);
-        throw new Error(`Failed to open DuckDB for ${repo.name}: ${msg}`);
+        throw new Error(`Failed to open graph store for ${repo.name}: ${msg}`);
       });
       try {
         const [consumers, producers] = await Promise.all([
diff --git a/packages/mcp/src/tools/group-query.ts b/packages/mcp/src/tools/group-query.ts
index 8612d10d..5fcc94cf 100644
--- a/packages/mcp/src/tools/group-query.ts
+++ b/packages/mcp/src/tools/group-query.ts
@@ -30,7 +30,7 @@
 import { resolve } from "node:path";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { bm25Search, DEFAULT_RRF_K, DEFAULT_RRF_TOP_K, rrf } from "@opencodehub/search";
-import { resolveDbPath } from "@opencodehub/storage";
+import { resolveGraphPath } from "@opencodehub/storage";
 import { z } from "zod";
 import { toolError, toolErrorFromUnknown } from "../error-envelope.js";
 import { readGroup } from "../group-resolver.js";
@@ -160,7 +160,7 @@ export async function runGroupQuery(ctx: ToolContext, args: GroupQueryArgs): Pro
       // helper falls back to `deriveRepoUri` on any DB failure.
       const repoUri = await repoUriForEntry(hit, ctx.pool);
       const repoPath = resolve(hit.path);
-      const dbPath = resolveDbPath(repoPath);
+      const dbPath = resolveGraphPath(repoPath);
 
       let store: Awaited<ReturnType<typeof ctx.pool.acquire>>;
       try {
diff --git a/packages/mcp/src/tools/group-tools.test.ts b/packages/mcp/src/tools/group-tools.test.ts
index cac3a849..2404bc1b 100644
--- a/packages/mcp/src/tools/group-tools.test.ts
+++ b/packages/mcp/src/tools/group-tools.test.ts
@@ -184,7 +184,7 @@ async function withTestHarness(
 
     // Fake store pool: hand back a fake for every repo path.
     const pool = new ConnectionPool({ max: 4, ttlMs: 60_000 }, async (dbPath) => {
-      // dbPath looks like <repoPath>/.codehub/graph.duckdb — match by repo name.
+      // dbPath looks like <repoPath>/.codehub/graph.lbug — match by repo name.
       for (const r of repos) {
         const rp = repoPaths.get(r.name);
         if (rp && dbPath.startsWith(rp)) {
diff --git a/packages/mcp/src/tools/list-dead-code.test.ts b/packages/mcp/src/tools/list-dead-code.test.ts
index 53324568..83ef684e 100644
--- a/packages/mcp/src/tools/list-dead-code.test.ts
+++ b/packages/mcp/src/tools/list-dead-code.test.ts
@@ -23,8 +23,8 @@ import type {
 } from "@opencodehub/core-types";
 import type {
   BulkLoadStats,
-  DuckDbStore,
   EmbeddingRow,
+  IGraphStore,
   ListEdgesByTypeOptions,
   ListEdgesOptions,
   ListNodesOptions,
@@ -42,17 +42,15 @@ import type { ToolContext } from "./shared.js";
 
 /**
  * Wrap an in-memory IGraphStore-shaped fake as the composed `Store`
- * (`OpenStoreResult`) that the connection pool returns. The same
- * instance backs both `graph` and `temporal` because DuckDbStore
- * implements both interfaces over a single connection in production.
+ * (`OpenStoreResult`) that the connection pool returns. The same fake
+ * instance backs both `graph` and `temporal` views.
  */
 function wrapAsStore(fake: unknown): import("@opencodehub/storage").Store {
   return {
-    backend: "duck" as const,
     graph: fake as import("@opencodehub/storage").IGraphStore,
     temporal: fake as import("@opencodehub/storage").ITemporalStore,
-    graphFile: "/in-memory/graph.duckdb",
-    temporalFile: "/in-memory/graph.duckdb",
+    graphFile: "/in-memory/graph.lbug",
+    temporalFile: "/in-memory/temporal.duckdb",
     close: async () => {
       const closer = (fake as { close?: () => Promise<void> }).close;
       if (typeof closer === "function") await closer.call(fake);
@@ -82,7 +80,7 @@ interface FakeEdge {
  * filtering semantics directly against the seeded `nodes` / `edges`
  * arrays.
  */
-function makeFakeStore(nodes: readonly FakeNode[], edges: readonly FakeEdge[]): DuckDbStore {
+function makeFakeStore(nodes: readonly FakeNode[], edges: readonly FakeEdge[]): IGraphStore {
   const nodeAsGraphNode = (n: FakeNode): GraphNode => n as unknown as GraphNode;
   const edgeAsRelation = (e: FakeEdge): CodeRelation =>
     ({
@@ -155,7 +153,7 @@ function makeFakeStore(nodes: readonly FakeNode[], edges: readonly FakeEdge[]):
     getMeta: async (): Promise<StoreMeta | undefined> => undefined,
     setMeta: async (_m: StoreMeta): Promise<void> => {},
     healthCheck: async () => ({ ok: true }),
-  } as unknown as DuckDbStore;
+  } as unknown as IGraphStore;
   return api;
 }
 
diff --git a/packages/mcp/src/tools/list-findings-delta.test.ts b/packages/mcp/src/tools/list-findings-delta.test.ts
index 5976ad6a..2b1a0c36 100644
--- a/packages/mcp/src/tools/list-findings-delta.test.ts
+++ b/packages/mcp/src/tools/list-findings-delta.test.ts
@@ -16,8 +16,8 @@ import type { KnowledgeGraph } from "@opencodehub/core-types";
 import type { SarifLog } from "@opencodehub/sarif";
 import type {
   BulkLoadStats,
-  DuckDbStore,
   EmbeddingRow,
+  IGraphStore,
   SearchQuery,
   SearchResult,
   SqlParam,
@@ -33,17 +33,15 @@ import type { ToolContext } from "./shared.js";
 
 /**
  * Wrap an in-memory IGraphStore-shaped fake as the composed `Store`
- * (`OpenStoreResult`) that the connection pool returns. The same
- * instance backs both `graph` and `temporal` because DuckDbStore
- * implements both interfaces over a single connection in production.
+ * (`OpenStoreResult`) that the connection pool returns. The same fake
+ * instance backs both `graph` and `temporal` views.
  */
 function wrapAsStore(fake: unknown): import("@opencodehub/storage").Store {
   return {
-    backend: "duck" as const,
     graph: fake as import("@opencodehub/storage").IGraphStore,
     temporal: fake as import("@opencodehub/storage").ITemporalStore,
-    graphFile: "/in-memory/graph.duckdb",
-    temporalFile: "/in-memory/graph.duckdb",
+    graphFile: "/in-memory/graph.lbug",
+    temporalFile: "/in-memory/temporal.duckdb",
     close: async () => {
       const closer = (fake as { close?: () => Promise<void> }).close;
       if (typeof closer === "function") await closer.call(fake);
@@ -51,7 +49,7 @@ function wrapAsStore(fake: unknown): import("@opencodehub/storage").Store {
   };
 }
 
-function makeFakeStore(): DuckDbStore {
+function makeFakeStore(): IGraphStore {
   const api = {
     open: async () => {},
     close: async () => {},
@@ -72,7 +70,7 @@ function makeFakeStore(): DuckDbStore {
     getMeta: async (): Promise<StoreMeta | undefined> => undefined,
     setMeta: async (_m: StoreMeta): Promise<void> => {},
     healthCheck: async () => ({ ok: true }),
-  } as unknown as DuckDbStore;
+  } as unknown as IGraphStore;
   return api;
 }
 
diff --git a/packages/mcp/src/tools/pack-codebase.ts b/packages/mcp/src/tools/pack-codebase.ts
index adc01e3e..a399f59c 100644
--- a/packages/mcp/src/tools/pack-codebase.ts
+++ b/packages/mcp/src/tools/pack-codebase.ts
@@ -254,15 +254,15 @@ async function callRealPackEngine(args: {
   const { mkdtemp, rename, rm } = await import("node:fs/promises");
   const { tmpdir } = await import("node:os");
   const { join, resolve } = await import("node:path");
-  const { openStore, resolveDbPath } = await import("@opencodehub/storage");
-  const dbPath = resolveDbPath(args.repo);
+  const { openStore, resolveGraphPath } = await import("@opencodehub/storage");
+  const dbPath = resolveGraphPath(args.repo);
   if (!existsSync(dbPath)) {
     throw new Error(
-      `pack_codebase: no graph index at ${dbPath}. ` +
+      `pack_codebase: no graph index at ${dbPath} (expected .codehub/graph.lbug). ` +
         "Run `codehub analyze` first to populate the store.",
     );
   }
-  const store = await openStore({ path: dbPath, backend: "duck", readOnly: true });
+  const store = await openStore({ path: dbPath, readOnly: true });
   const stagingDir = await mkdtemp(join(tmpdir(), "codehub-pack-mcp-"));
   try {
     const manifest = await defaultGeneratePack(
diff --git a/packages/mcp/src/tools/query.test.ts b/packages/mcp/src/tools/query.test.ts
index ced9867b..6be1ea01 100644
--- a/packages/mcp/src/tools/query.test.ts
+++ b/packages/mcp/src/tools/query.test.ts
@@ -33,8 +33,8 @@ import type { Embedder } from "@opencodehub/embedder";
 import type {
   AncestorTraversalOptions,
   BulkLoadStats,
-  DuckDbStore,
   EmbeddingRow,
+  IGraphStore,
   ListEdgesByTypeOptions,
   ListEdgesOptions,
   ListNodesOptions,
@@ -55,17 +55,15 @@ import type { EmbedderFactory, ToolContext } from "./shared.js";
 
 /**
  * Wrap an in-memory IGraphStore-shaped fake as the composed `Store`
- * (`OpenStoreResult`) that the connection pool returns. The same
- * instance backs both `graph` and `temporal` because DuckDbStore
- * implements both interfaces over a single connection in production.
+ * (`OpenStoreResult`) that the connection pool returns. The same fake
+ * instance backs both `graph` and `temporal` views.
  */
 function wrapAsStore(fake: unknown): import("@opencodehub/storage").Store {
   return {
-    backend: "duck" as const,
     graph: fake as import("@opencodehub/storage").IGraphStore,
     temporal: fake as import("@opencodehub/storage").ITemporalStore,
-    graphFile: "/in-memory/graph.duckdb",
-    temporalFile: "/in-memory/graph.duckdb",
+    graphFile: "/in-memory/graph.lbug",
+    temporalFile: "/in-memory/temporal.duckdb",
     close: async () => {
       const closer = (fake as { close?: () => Promise<void> }).close;
       if (typeof closer === "function") await closer.call(fake);
@@ -135,7 +133,7 @@ interface FakeStoreOptions {
 }
 
 interface FakeStoreHandle {
-  store: DuckDbStore;
+  store: IGraphStore;
   vectorCalls: number;
   searchCalls: number;
   /**
@@ -205,7 +203,7 @@ function buildProcessGraph(opts: FakeStoreOptions): {
 
 function makeFakeStore(opts: FakeStoreOptions): FakeStoreHandle {
   const handle: FakeStoreHandle = {
-    store: {} as DuckDbStore,
+    store: {} as IGraphStore,
     vectorCalls: 0,
     searchCalls: 0,
     lastSearchText: null,
@@ -377,7 +375,7 @@ function makeFakeStore(opts: FakeStoreOptions): FakeStoreHandle {
       });
       return out;
     },
-  } as unknown as DuckDbStore;
+  } as unknown as IGraphStore;
   handle.store = impl;
   return handle;
 }
diff --git a/packages/mcp/src/tools/remove-dead-code.test.ts b/packages/mcp/src/tools/remove-dead-code.test.ts
index 09b1cc5e..4aac8e4d 100644
--- a/packages/mcp/src/tools/remove-dead-code.test.ts
+++ b/packages/mcp/src/tools/remove-dead-code.test.ts
@@ -25,8 +25,8 @@ import type {
 } from "@opencodehub/core-types";
 import type {
   BulkLoadStats,
-  DuckDbStore,
   EmbeddingRow,
+  IGraphStore,
   ListEdgesByTypeOptions,
   ListEdgesOptions,
   ListNodesOptions,
@@ -43,17 +43,15 @@ import { type RemoveDeadCodeContext, registerRemoveDeadCodeTool } from "./remove
 
 /**
  * Wrap an in-memory IGraphStore-shaped fake as the composed `Store`
- * (`OpenStoreResult`) that the connection pool returns. The same
- * instance backs both `graph` and `temporal` because DuckDbStore
- * implements both interfaces over a single connection in production.
+ * (`OpenStoreResult`) that the connection pool returns. The same fake
+ * instance backs both `graph` and `temporal` views.
  */
 function wrapAsStore(fake: unknown): import("@opencodehub/storage").Store {
   return {
-    backend: "duck" as const,
     graph: fake as import("@opencodehub/storage").IGraphStore,
     temporal: fake as import("@opencodehub/storage").ITemporalStore,
-    graphFile: "/in-memory/graph.duckdb",
-    temporalFile: "/in-memory/graph.duckdb",
+    graphFile: "/in-memory/graph.lbug",
+    temporalFile: "/in-memory/temporal.duckdb",
     close: async () => {
       const closer = (fake as { close?: () => Promise<void> }).close;
       if (typeof closer === "function") await closer.call(fake);
@@ -78,7 +76,7 @@ interface FakeNode {
  * path looks for inbound referrers but we only seed isolated dead
  * candidates).
  */
-function makeFakeStore(nodes: readonly FakeNode[]): DuckDbStore {
+function makeFakeStore(nodes: readonly FakeNode[]): IGraphStore {
   const nodeAsGraphNode = (n: FakeNode): GraphNode => n as unknown as GraphNode;
 
   const api = {
@@ -117,7 +115,7 @@ function makeFakeStore(nodes: readonly FakeNode[]): DuckDbStore {
     getMeta: async (): Promise<StoreMeta | undefined> => undefined,
     setMeta: async (_m: StoreMeta): Promise<void> => {},
     healthCheck: async () => ({ ok: true }),
-  } as unknown as DuckDbStore;
+  } as unknown as IGraphStore;
   return api;
 }
 
diff --git a/packages/mcp/src/tools/run-smoke.test.ts b/packages/mcp/src/tools/run-smoke.test.ts
index 4174f891..eb962162 100644
--- a/packages/mcp/src/tools/run-smoke.test.ts
+++ b/packages/mcp/src/tools/run-smoke.test.ts
@@ -19,8 +19,8 @@ import { test } from "node:test";
 import type { KnowledgeGraph } from "@opencodehub/core-types";
 import type {
   BulkLoadStats,
-  DuckDbStore,
   EmbeddingRow,
+  IGraphStore,
   SearchQuery,
   SearchResult,
   SqlParam,
@@ -63,17 +63,15 @@ import { runVerdict } from "./verdict.js";
 
 /**
  * Wrap an in-memory IGraphStore-shaped fake as the composed `Store`
- * (`OpenStoreResult`) that the connection pool returns. The same
- * instance backs both `graph` and `temporal` because DuckDbStore
- * implements both interfaces over a single connection in production.
+ * (`OpenStoreResult`) that the connection pool returns. The same fake
+ * instance backs both `graph` and `temporal` views.
  */
 function wrapAsStore(fake: unknown): import("@opencodehub/storage").Store {
   return {
-    backend: "duck" as const,
     graph: fake as import("@opencodehub/storage").IGraphStore,
     temporal: fake as import("@opencodehub/storage").ITemporalStore,
-    graphFile: "/in-memory/graph.duckdb",
-    temporalFile: "/in-memory/graph.duckdb",
+    graphFile: "/in-memory/graph.lbug",
+    temporalFile: "/in-memory/temporal.duckdb",
     close: async () => {
       const closer = (fake as { close?: () => Promise<void> }).close;
       if (typeof closer === "function") await closer.call(fake);
@@ -89,7 +87,7 @@ function wrapAsStore(fake: unknown): import("@opencodehub/storage").Store {
  * with the expected structured-content fields, so the smoke tests only
  * assert the `ToolResult` shape.
  */
-function makeFakeStore(): DuckDbStore {
+function makeFakeStore(): IGraphStore {
   const api = {
     open: async () => {},
     close: async () => {},
@@ -116,7 +114,7 @@ function makeFakeStore(): DuckDbStore {
     bulkLoadCochanges: async (_rows: readonly unknown[]): Promise<void> => {},
     lookupCochangesForFile: async () => [],
     lookupCochangesBetween: async () => undefined,
-  } as unknown as DuckDbStore;
+  } as unknown as IGraphStore;
   return api;
 }
 
diff --git a/packages/mcp/src/tools/shared.ts b/packages/mcp/src/tools/shared.ts
index 91846a7d..102bcbdb 100644
--- a/packages/mcp/src/tools/shared.ts
+++ b/packages/mcp/src/tools/shared.ts
@@ -164,17 +164,13 @@ export async function withStore(
     store = await ctx.pool.acquire(resolved.repoPath, resolved.dbPath);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    // Enumerate every in-tree backend's artifact filename so the hint is
-    // useful regardless of which backend produced the index. Pulling the
-    // filenames from `describeArtifacts` keeps two-store deployments in
-    // sync with a single source of truth.
-    const candidates = (["duck", "lbug"] as const)
-      .map((b) => `.codehub/${describeArtifacts(b).graphFile}`)
-      .join(" or ");
+    // Pull the canonical graph artifact filename from `describeArtifacts`
+    // so the hint stays in sync with the storage layer's source of truth.
+    const candidate = `.codehub/${describeArtifacts().graphFile}`;
     return toolError(
       "DB_ERROR",
       `Failed to open store at ${resolved.dbPath}: ${msg}`,
-      `Ensure the repo was indexed and that the ${candidates} file is readable.`,
+      `Ensure the repo was indexed and that the ${candidate} file is readable.`,
     );
   }
   try {
diff --git a/packages/mcp/src/tools/sql.test.ts b/packages/mcp/src/tools/sql.test.ts
index 157b5e88..41e76615 100644
--- a/packages/mcp/src/tools/sql.test.ts
+++ b/packages/mcp/src/tools/sql.test.ts
@@ -3,15 +3,12 @@
  * Behavioural tests for the `sql` MCP tool's dual-emit surface.
  *
  * The surface we exercise:
- *   1. Existing SQL path behaves exactly as before when only `sql` is set.
- *   2. `cypher` field is accepted when `CODEHUB_STORE=lbug`.
- *   3. `cypher` field is rejected with a clear hint when `CODEHUB_STORE` is
- *      unset or `=duck`.
- *   4. Both `sql` and `cypher` supplied → INVALID_INPUT "choose one".
- *   5. Neither supplied → INVALID_INPUT.
- *   6. Cypher write verbs are rejected by `cypher-guard` before reaching
- *      the store (no exec call on the guard-rejected path).
- *   7. Cypher read path invokes `graph.execCypher` with the cypher text.
+ *   1. SQL path routes through `temporal.exec()` and returns rows.
+ *   2. Cypher path routes through `graph.execCypher()` and returns rows.
+ *   3. Both `sql` and `cypher` supplied → INVALID_INPUT "choose one".
+ *   4. Neither supplied → INVALID_INPUT.
+ *   5. SQL write verbs are rejected by `sql-guard` (INVALID_INPUT).
+ *   6. Cypher write verbs are rejected by `cypher-guard` (INVALID_INPUT).
  */
 
 import { strict as assert } from "node:assert";
@@ -63,7 +60,6 @@ interface HarnessContext {
 interface HarnessOptions {
   readonly rows?: readonly Record<string, unknown>[];
   readonly guard?: (stmt: string) => void;
-  readonly codehubStore?: string;
 }
 
 async function withHarness(
@@ -77,16 +73,8 @@ async function withHarness(
     store: undefined as unknown as import("@opencodehub/storage").Store,
   };
 
-  const priorStore = process.env["CODEHUB_STORE"];
-  if (harnessOpts.codehubStore === undefined) {
-    delete process.env["CODEHUB_STORE"];
-  } else {
-    process.env["CODEHUB_STORE"] = harnessOpts.codehubStore;
-  }
-  const restoreEnv = () => {
-    if (priorStore === undefined) delete process.env["CODEHUB_STORE"];
-    else process.env["CODEHUB_STORE"] = priorStore;
-  };
+  // Cypher is now unconditionally available — no environment plumbing.
+  const restoreEnv = () => {};
 
   try {
     await withMcpHarness(
@@ -129,7 +117,7 @@ async function withHarness(
         const ctx: ToolContext = { pool, home };
         // Acquire once just to seed handle.store for spy-based tests.
         const repoPath = `${home}/fakerepo`;
-        const dbPath = `${repoPath}/.codehub/graph.duckdb`;
+        const dbPath = `${repoPath}/.codehub/graph.lbug`;
         try {
           handle.store = await pool.acquire(repoPath, dbPath);
         } finally {
@@ -217,7 +205,7 @@ test("sql: SQL write verb is rejected by sql-guard → INVALID_INPUT", async ()
 // ---------------------------------------------------------------------------
 
 test("sql: both `sql` and `cypher` provided → INVALID_INPUT (choose one)", async () => {
-  await withHarness({ rows: [], codehubStore: "lbug" }, async ({ ctx, server, handle }) => {
+  await withHarness({ rows: [] }, async ({ ctx, server, handle }) => {
     registerSqlTool(server, ctx);
     const handler = getHandler(server, "sql");
     const result = await handler(
@@ -256,55 +244,13 @@ test("sql: neither `sql` nor `cypher` provided → INVALID_INPUT", async () => {
 });
 
 // ---------------------------------------------------------------------------
-// Cypher availability gate (CODEHUB_STORE env var)
-// ---------------------------------------------------------------------------
-
-test("sql: `cypher` is rejected when CODEHUB_STORE is unset", async () => {
-  await withHarness({ rows: [] }, async ({ ctx, server, handle }) => {
-    registerSqlTool(server, ctx);
-    const handler = getHandler(server, "sql");
-    const result = await handler({ cypher: "MATCH (n) RETURN n", repo: "fakerepo" }, {});
-    const sc = result.structuredContent as {
-      error?: { code: string; message: string; hint?: string };
-    };
-    assert.equal(result.isError, true);
-    assert.equal(sc.error?.code, "INVALID_INPUT");
-    assert.ok(
-      sc.error?.message.includes("cypher unavailable"),
-      `expected unavailability message, got: ${sc.error?.message}`,
-    );
-    assert.ok(
-      sc.error?.message.includes("CODEHUB_STORE=lbug"),
-      `expected env-var hint in message, got: ${sc.error?.message}`,
-    );
-    assert.equal(handle.execCalls.length, 0, "store must not be queried when cypher is refused");
-  });
-});
-
-test("sql: `cypher` is rejected when CODEHUB_STORE=duck", async () => {
-  await withHarness({ rows: [], codehubStore: "duck" }, async ({ ctx, server, handle }) => {
-    registerSqlTool(server, ctx);
-    const handler = getHandler(server, "sql");
-    const result = await handler({ cypher: "MATCH (n) RETURN n", repo: "fakerepo" }, {});
-    const sc = result.structuredContent as {
-      error?: { code: string; message: string };
-    };
-    assert.equal(result.isError, true);
-    assert.equal(sc.error?.code, "INVALID_INPUT");
-    assert.ok(sc.error?.message.includes("cypher unavailable"));
-    assert.equal(handle.execCalls.length, 0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Cypher path (CODEHUB_STORE=lbug)
+// Cypher path
 // ---------------------------------------------------------------------------
 
-test("sql: `cypher` accepted when CODEHUB_STORE=lbug; store.query receives the cypher text", async () => {
+test("sql: `cypher` routes through `graph.execCypher` and the cypher text reaches the store unchanged", async () => {
   await withHarness(
     {
       rows: [{ node_id: "F:foo", name: "foo" }],
-      codehubStore: "lbug",
       // In production, a GraphDbStore runs assertReadOnlyCypher internally;
       // mirror that so the test matches the end-to-end contract.
       guard: assertReadOnlyCypher,
@@ -337,7 +283,6 @@ test("sql: cypher write verb is rejected by cypher-guard → INVALID_INPUT", asy
   await withHarness(
     {
       rows: [],
-      codehubStore: "lbug",
       guard: assertReadOnlyCypher,
     },
     async ({ ctx, server, handle }) => {
@@ -380,7 +325,6 @@ test("sql: cypher read path tolerates an unknown keyword that is NOT a write ver
   await withHarness(
     {
       rows: [{ id: "F:foo" }],
-      codehubStore: "lbug",
       guard: assertReadOnlyCypher,
     },
     async ({ ctx, server, handle }) => {
diff --git a/packages/mcp/src/tools/sql.ts b/packages/mcp/src/tools/sql.ts
index e419147e..187c7ff7 100644
--- a/packages/mcp/src/tools/sql.ts
+++ b/packages/mcp/src/tools/sql.ts
@@ -1,19 +1,17 @@
 /**
  * `sql` — raw read-only SQL / Cypher over the local graph store.
  *
- * The tool accepts either `sql` (DuckDB backend) or `cypher` (graph-db
- * backend, `CODEHUB_STORE=lbug`) — exactly one per call. The read-only
- * guards (`assertReadOnlySql` / `assertReadOnlyCypher`) reject any write
- * verb before the statement reaches the underlying engine.
+ * The tool accepts either `sql` (temporal DuckDB view) or `cypher`
+ * (graph lbug view) — exactly one per call. The read-only guards
+ * (`assertReadOnlySql` / `assertReadOnlyCypher`) reject any write verb
+ * before the statement reaches the underlying engine.
  *
  * - SQL path: `SqlGuardError` on violation → INVALID_INPUT envelope.
  * - Cypher path: `CypherGuardError` on violation → INVALID_INPUT envelope.
- * - Cypher path without `CODEHUB_STORE=lbug` → INVALID_INPUT with a
- *   "cypher unavailable" hint.
  * - Both `sql` and `cypher` supplied → INVALID_INPUT "choose one".
  *
  * A default 5 s timeout caps runaway queries (DuckDB itself has no SQL
- * timeout — the adapter interrupts via a JS timer; the graph-db adapter
+ * timeout — the adapter interrupts via a JS timer; the graph adapter
  * honours `timeoutMs` through its pool).
  *
  * The tool description embeds the node-kind and relation-type vocabulary
@@ -42,14 +40,14 @@ const SqlInput = {
     .min(1)
     .optional()
     .describe(
-      "Read-only SQL statement (DuckDB backend). INSERT/UPDATE/DELETE/DDL are rejected by the guard. Provide exactly one of `sql` or `cypher`.",
+      "Read-only SQL statement against the temporal DuckDB view. INSERT/UPDATE/DELETE/DDL are rejected by the guard. Provide exactly one of `sql` or `cypher`.",
     ),
   cypher: z
     .string()
     .min(1)
     .optional()
     .describe(
-      "Read-only Cypher statement (graph-db backend; requires `CODEHUB_STORE=lbug`). CREATE/DELETE/SET/MERGE/REMOVE/DROP are rejected by the guard. Provide exactly one of `sql` or `cypher`.",
+      "Read-only Cypher statement against the graph view (lbug). CREATE/DELETE/SET/MERGE/REMOVE/DROP are rejected by the guard. Provide exactly one of `sql` or `cypher`.",
     ),
   ...repoArgShape,
   timeout_ms: z
@@ -75,15 +73,6 @@ interface SqlArgs {
   readonly timeout_ms?: number | undefined;
 }
 
-/**
- * Determine the configured backend from the environment. Exposed as a
- * thin indirection so tests can flip the env var mid-run without touching
- * the tool surface.
- */
-function isGraphDbBackend(env: NodeJS.ProcessEnv = process.env): boolean {
-  return env["CODEHUB_STORE"] === "lbug";
-}
-
 export async function runSql(ctx: ToolContext, args: SqlArgs): Promise<ToolResult> {
   // Exactly-one-of input guard. The Zod schema marks both fields optional
   // so we can emit a targeted error envelope rather than a schema-level
@@ -95,7 +84,7 @@ export async function runSql(ctx: ToolContext, args: SqlArgs): Promise<ToolResul
       toolError(
         "INVALID_INPUT",
         "provide exactly one of `sql` or `cypher`",
-        "The sql tool accepts either a SQL statement (DuckDB backend) or a Cypher statement (graph-db backend), not both.",
+        "The sql tool accepts either a SQL statement (temporal DuckDB view) or a Cypher statement (graph view), not both.",
       ),
     );
   }
@@ -108,15 +97,6 @@ export async function runSql(ctx: ToolContext, args: SqlArgs): Promise<ToolResul
       ),
     );
   }
-  if (hasCypher && !isGraphDbBackend()) {
-    return toToolResult(
-      toolError(
-        "INVALID_INPUT",
-        "cypher unavailable without `CODEHUB_STORE=lbug`",
-        "Set `CODEHUB_STORE=lbug` in the MCP server's environment to enable the graph-db backend. The default DuckDB backend only speaks SQL.",
-      ),
-    );
-  }
 
   const timeoutMs = args.timeout_ms ?? 5000;
   // Exactly one of these is defined at this point; TypeScript cannot
@@ -142,9 +122,9 @@ export async function runSql(ctx: ToolContext, args: SqlArgs): Promise<ToolResul
         const exec = store.graph.execCypher;
         if (typeof exec !== "function") {
           return toolError(
-            "INVALID_INPUT",
+            "INTERNAL",
             "cypher unavailable: graph adapter does not expose execCypher",
-            "Set `CODEHUB_STORE=lbug` to enable the graph-db backend that exposes the Cypher escape hatch.",
+            "The graph adapter is missing the `execCypher` escape hatch — re-run `codehub analyze` to rebuild the index against the lbug-backed graph store.",
           );
         }
         rawRows = await exec.call(store.graph, statement);
@@ -209,7 +189,7 @@ export function registerSqlTool(server: McpServer, ctx: ToolContext): void {
     {
       title: "Read-only SQL / Cypher over the code graph",
       description: [
-        "Execute a read-only query against the local graph store. Supply EXACTLY ONE of `sql` (DuckDB backend, default) or `cypher` (graph-db backend, requires `CODEHUB_STORE=lbug`). Results are returned as a markdown table plus raw row objects. Use this for one-off questions that the higher-level tools don't cover — e.g. 'find every exported function in src/auth/'.",
+        "Execute a read-only query against the local graph store. Supply EXACTLY ONE of `sql` (temporal DuckDB view) or `cypher` (graph view). Results are returned as a markdown table plus raw row objects. Use this for one-off questions that the higher-level tools don't cover — e.g. 'find every exported function in src/auth/'.",
         "",
         SCHEMA_HINT,
       ].join("\n"),
diff --git a/packages/pack/src/embeddings-sidecar.test.ts b/packages/pack/src/embeddings-sidecar.test.ts
index 52b29c2b..d0fc6eff 100644
--- a/packages/pack/src/embeddings-sidecar.test.ts
+++ b/packages/pack/src/embeddings-sidecar.test.ts
@@ -1,111 +1,85 @@
 /**
- * Tests for the Parquet embeddings sidecar.
+ * Tests for `writeEmbeddingsSidecar`.
  *
- * Sidecar emission lives in pack/, not in `@opencodehub/storage`. The
- * sidecar consumes embeddings via the portable
- * {@link IGraphStore.listEmbeddings} stream and writes Parquet via
- * DuckDB COPY. Tests cover three tiers:
+ * The sidecar streams embeddings out of the graph store (lbug in production)
+ * into a per-call temp table on `temporal.duckdb`, then runs DuckDB's
+ * deterministic `COPY (... ORDER BY ...) TO '...' (FORMAT PARQUET, COMPRESSION
+ * ZSTD)` to produce the byte-identical Parquet sidecar.
  *
- *   1. Pure-mock dispatch tests (always run, no native bindings):
- *      - Duck-path fake exposing the @internal `exportEmbeddingsParquet`
- *        helper → `written: true`, `writerBackend: "duck-copy"`.
- *      - Duck-path fake reporting `rowCount: 0` → `written: false`,
- *        `writerBackend: "absent"`, `determinismClass: "strict"`.
- *      - lbug-path fake → `written: false`, `writerBackend: "absent"`,
- *        `determinismClass: "degraded"` when embeddings exist (v1 defers
- *        Parquet emission on lbug-only deployments).
- *
- *   2. Real-DuckDB byte-identity test (skipped when `@duckdb/node-api`
- *      native binding fails to load — worktree native bindings may not
- *      always rebuild cleanly). When it runs:
- *      - 100 row × 384-dim Float32Array fixture.
- *      - Two consecutive `writeEmbeddingsSidecar` runs against the same
- *        store produce byte-identical Parquet files.
- *      - `pinsHint.duckdbVersion` is populated and non-empty.
+ * Coverage tiers:
+ *   1. Mock-only dispatch: empty input → no file; non-empty input → file with
+ *      hash + size + duckdbVersion stamped.
+ *   2. Real-backend byte-identity: opens a real DuckDbStore as the temporal
+ *      view, drives a synthetic graph stream through it, runs the sidecar
+ *      twice, asserts file SHA equality. Skipped when native DuckDB binding
+ *      can't load.
  */
 
-import { strict as assert } from "node:assert";
+import assert from "node:assert/strict";
 import { existsSync } from "node:fs";
 import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { describe, it, test } from "node:test";
-import type { EmbeddingRow, IGraphStore, ITemporalStore, Store } from "@opencodehub/storage";
-import { writeEmbeddingsSidecar } from "./embeddings-sidecar.js";
+import type { EmbeddingRow, Store } from "@opencodehub/storage";
 
-// ---------------------------------------------------------------------------
-// Pure-mock helpers — exercise every code path that does not touch DuckDB.
-// ---------------------------------------------------------------------------
+import { writeEmbeddingsSidecar } from "./embeddings-sidecar.js";
 
-/**
- * Build a mock {@link IGraphStore}. Only `listEmbeddings` is wired (the
- * surface the sidecar actually reads); other finders throw if invoked.
- */
-function makeMockGraph(rows: readonly EmbeddingRow[] = []): IGraphStore {
-  return {
-    listEmbeddings: async function* () {
-      for (const r of rows) yield r;
-    },
-  } as unknown as IGraphStore;
+async function tempDir(): Promise<string> {
+  return mkdtemp(path.join(tmpdir(), "sidecar-"));
 }
 
-/**
- * Wrap a graph store + optional COPY helper into the {@link Store} shape
- * the sidecar consumes. `backend` is the dispatch axis the sidecar
- * narrows on; `temporal` is unused on the duck path so we cast the graph
- * stand-in into temporal-shape when the caller wants the duck-typed COPY
- * helper attached to the graph view.
- */
-function makeMockStore(opts: {
-  backend: "duck" | "lbug";
-  graph?: IGraphStore;
-  copyHelper?: (
+interface MockOpts {
+  readonly rows: readonly EmbeddingRow[];
+  /** Override the COPY step. When omitted, writes a deterministic placeholder. */
+  readonly export?: (
+    rows: AsyncIterable<EmbeddingRow>,
     absPath: string,
   ) => Promise<{ readonly rowCount: number; readonly duckdbVersion: string }>;
-  rows?: readonly EmbeddingRow[];
-}): Store {
-  const graphBase = opts.graph ?? makeMockGraph(opts.rows ?? []);
-  const graphWithHelper =
-    opts.copyHelper !== undefined
-      ? Object.assign(Object.create(null) as object, graphBase, {
-          exportEmbeddingsParquet: opts.copyHelper,
-        })
-      : graphBase;
+}
+
+function makeMockStore(opts: MockOpts): Store {
+  const graph = {
+    listEmbeddings: async function* () {
+      for (const row of opts.rows) yield row;
+    },
+  } as unknown as Store["graph"];
+
+  const exporter =
+    opts.export ??
+    (async (rows: AsyncIterable<EmbeddingRow>, absPath: string) => {
+      let n = 0;
+      const buf: string[] = [];
+      for await (const r of rows) {
+        n += 1;
+        buf.push(
+          `${r.nodeId}\t${r.granularity ?? "symbol"}\t${r.chunkIndex}\t${[...r.vector].join(",")}`,
+        );
+      }
+      if (n > 0) await writeFile(absPath, buf.join("\n"));
+      return { rowCount: n, duckdbVersion: "mock-1.0.0" };
+    });
+
+  const temporal = {
+    exportEmbeddingsToParquet: exporter,
+  } as unknown as Store["temporal"];
+
   return {
-    backend: opts.backend,
-    graph: graphWithHelper as IGraphStore,
-    temporal: graphWithHelper as unknown as ITemporalStore,
+    graph,
+    temporal,
     graphFile: ":memory:",
     temporalFile: ":memory:",
-    close: async () => {
-      /* no-op */
-    },
+    close: async () => {},
   };
 }
 
-async function tempDir(): Promise<string> {
-  return mkdtemp(path.join(tmpdir(), "sidecar-"));
-}
-
-// ---------------------------------------------------------------------------
-// Pure-mock dispatch tests
-// ---------------------------------------------------------------------------
-
-describe("writeEmbeddingsSidecar — duck-path dispatch (mock)", () => {
-  it("returns written=false, writerBackend=absent when COPY reports rowCount=0", async () => {
+describe("writeEmbeddingsSidecar — mock dispatch", () => {
+  it("returns written=false, writerBackend=absent for empty embeddings", async () => {
     const dir = await tempDir();
     try {
-      let calls = 0;
-      const store = makeMockStore({
-        backend: "duck",
-        copyHelper: async () => {
-          calls += 1;
-          return { rowCount: 0, duckdbVersion: "1.4.0" };
-        },
-      });
+      const store = makeMockStore({ rows: [] });
       const outPath = path.join(dir, "embeddings.parquet");
       const result = await writeEmbeddingsSidecar({ store, outPath });
-      assert.equal(calls, 1, "duck-path must invoke the COPY helper");
       assert.equal(result.written, false);
       assert.equal(result.writerBackend, "absent");
       assert.equal(result.determinismClass, "strict");
@@ -113,90 +87,66 @@ describe("writeEmbeddingsSidecar — duck-path dispatch (mock)", () => {
       assert.equal(result.bytesWritten, 0);
       assert.equal(result.fileHash, undefined);
       assert.equal(result.pinsHint.duckdbVersion, undefined);
-      assert.equal(existsSync(outPath), false, "no file when rowCount=0");
+      assert.equal(existsSync(outPath), false);
     } finally {
       await rm(dir, { recursive: true, force: true });
     }
   });
 
-  it("returns written=true with hash + size when the duck COPY helper writes a file", async () => {
+  it("returns written=true with hash + size + duckdbVersion when rows are present", async () => {
     const dir = await tempDir();
     try {
-      const fixtureBytes = new Uint8Array([0x50, 0x41, 0x52, 0x31]); // "PAR1" magic.
-      const store = makeMockStore({
-        backend: "duck",
-        copyHelper: async (absPath: string) => {
-          await writeFile(absPath, fixtureBytes);
-          return { rowCount: 7, duckdbVersion: "v1.3.2" };
+      const rows: EmbeddingRow[] = [
+        {
+          nodeId: "Function:a.ts:fn",
+          granularity: "symbol",
+          chunkIndex: 0,
+          vector: new Float32Array([0.1, 0.2, 0.3]),
+          contentHash: "h-0",
         },
-      });
+      ];
+      const store = makeMockStore({ rows });
       const outPath = path.join(dir, "embeddings.parquet");
       const result = await writeEmbeddingsSidecar({ store, outPath });
       assert.equal(result.written, true);
       assert.equal(result.writerBackend, "duck-copy");
       assert.equal(result.determinismClass, "strict");
-      assert.equal(result.rowCount, 7);
-      assert.equal(result.bytesWritten, fixtureBytes.byteLength);
-      assert.equal(result.pinsHint.duckdbVersion, "v1.3.2");
-      const onDisk = await readFile(outPath);
-      const expected = await import("node:crypto").then((c) =>
-        c.createHash("sha256").update(onDisk).digest("hex"),
-      );
-      assert.equal(result.fileHash, expected);
+      assert.equal(result.rowCount, 1);
+      assert.ok(result.bytesWritten > 0);
+      assert.equal(result.pinsHint.duckdbVersion, "mock-1.0.0");
+      assert.ok(result.fileHash && result.fileHash.length === 64);
     } finally {
       await rm(dir, { recursive: true, force: true });
     }
   });
-});
 
-describe("writeEmbeddingsSidecar — lbug-path degraded stamp (mock)", () => {
-  it("stamps determinismClass=degraded when graph has rows but no COPY helper is reachable", async () => {
+  it("filters by granularity when supplied", async () => {
     const dir = await tempDir();
     try {
       const rows: EmbeddingRow[] = [
         {
-          nodeId: "fn:a",
+          nodeId: "n1",
           granularity: "symbol",
           chunkIndex: 0,
-          vector: Float32Array.from([0.1, 0.2, 0.3]),
-          contentHash: "h1",
+          vector: new Float32Array([1]),
+          contentHash: "h",
         },
         {
-          nodeId: "fn:b",
-          granularity: "symbol",
+          nodeId: "n2",
+          granularity: "file",
           chunkIndex: 0,
-          vector: Float32Array.from([0.4, 0.5, 0.6]),
-          contentHash: "h2",
+          vector: new Float32Array([2]),
+          contentHash: "h",
         },
       ];
-      const store = makeMockStore({ backend: "lbug", rows });
+      const store = makeMockStore({ rows });
       const outPath = path.join(dir, "embeddings.parquet");
-      const result = await writeEmbeddingsSidecar({ store, outPath });
-      assert.equal(result.written, false);
-      assert.equal(result.writerBackend, "absent");
-      assert.equal(
-        result.determinismClass,
-        "degraded",
-        "lbug + non-empty embeddings must stamp degraded for v1",
-      );
-      assert.equal(result.rowCount, 2);
-      assert.equal(result.bytesWritten, 0);
-      assert.equal(existsSync(outPath), false, "no file on lbug v1");
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("keeps determinismClass=strict on lbug when there are zero embeddings (absence is deterministic)", async () => {
-    const dir = await tempDir();
-    try {
-      const store = makeMockStore({ backend: "lbug", rows: [] });
-      const outPath = path.join(dir, "embeddings.parquet");
-      const result = await writeEmbeddingsSidecar({ store, outPath });
-      assert.equal(result.written, false);
-      assert.equal(result.writerBackend, "absent");
-      assert.equal(result.determinismClass, "strict");
-      assert.equal(result.rowCount, 0);
+      const result = await writeEmbeddingsSidecar({
+        store,
+        outPath,
+        granularity: "file",
+      });
+      assert.equal(result.rowCount, 1, "granularity filter must drop non-matches");
     } finally {
       await rm(dir, { recursive: true, force: true });
     }
@@ -204,89 +154,60 @@ describe("writeEmbeddingsSidecar — lbug-path degraded stamp (mock)", () => {
 });
 
 // ---------------------------------------------------------------------------
-// Byte-identity test against a real DuckDbStore. The native binding may
-// fail to rebuild in worktrees — wrap the entire test in a try/catch and
-// skip with a logged note when DuckDB cannot be loaded. The main
-// checkout re-validates with bindings present so any divergence still
-// gets caught upstream.
+// Real-backend byte-identity test — opens a real DuckDbStore for temporal,
+// drives a synthetic graph stream, asserts SHA equality across two runs.
 // ---------------------------------------------------------------------------
 
-test("writeEmbeddingsSidecar — populated duck path is byte-identical across two runs", async () => {
+test("byte-identity: two runs against same input produce identical Parquet", async () => {
   let DuckDbStore: typeof import("@opencodehub/storage").DuckDbStore;
   try {
     ({ DuckDbStore } = await import("@opencodehub/storage"));
   } catch (err) {
-    // istanbul ignore next — defensive only; @opencodehub/storage is a
-    // workspace dep so the import itself shouldn't fail.
     assert.ok(true, `skipping: workspace import failed (${(err as Error).message})`);
     return;
   }
 
-  const { KnowledgeGraph, makeNodeId } = await import("@opencodehub/core-types");
-
   const dir = await tempDir();
-  const dbPath = path.join(dir, "graph.duckdb");
+  const dbPath = path.join(dir, "temporal.duckdb");
   const outA = path.join(dir, "a.parquet");
   const outB = path.join(dir, "b.parquet");
 
-  let store: import("@opencodehub/storage").DuckDbStore;
+  let temporal: import("@opencodehub/storage").DuckDbStore;
   try {
-    store = new DuckDbStore(dbPath, { embeddingDim: 384 });
-    await store.open();
+    temporal = new DuckDbStore(dbPath);
+    await temporal.open();
+    await temporal.createSchema();
   } catch (err) {
-    // Native binding load failure — log and skip; worktree bindings
-    // may not always rebuild cleanly.
     await rm(dir, { recursive: true, force: true });
     assert.ok(
       true,
-      `skipping byte-identity test: DuckDB native binding unavailable (${(err as Error).message})`,
+      `skipping byte-identity test: DuckDB binding unavailable (${(err as Error).message})`,
     );
     return;
   }
 
   try {
-    await store.createSchema();
-
-    // Build a 100-node graph + 100 × 384-dim Float32 embeddings. Use a
-    // deterministic seed so two test invocations agree byte-for-byte (the
-    // store itself is destroyed between tests, but determinism inside one
-    // test is what the AC measures).
-    const graph = new KnowledgeGraph();
-    const ids: string[] = [];
-    for (let i = 0; i < 100; i += 1) {
-      const id = makeNodeId("Function", `src/f${i}.ts`, `f${i}`);
-      ids.push(id);
-      graph.addNode({
-        id,
-        kind: "Function",
-        name: `f${i}`,
-        filePath: `src/f${i}.ts`,
-        startLine: 1,
-        endLine: 5,
-      });
-    }
-    await store.bulkLoad(graph);
-
-    const rows = ids.map((nodeId, i) => ({
-      nodeId,
+    const rows: EmbeddingRow[] = Array.from({ length: 100 }, (_, i) => ({
+      nodeId: `Function:src/f${i}.ts:f${i}`,
       granularity: "symbol" as const,
       chunkIndex: 0,
-      vector: deterministicVector(i, 384),
+      vector: deterministicVector(i, 64),
       contentHash: `h-${i.toString().padStart(3, "0")}`,
     }));
-    await store.upsertEmbeddings(rows);
 
-    // Build a duck-shape Store wrapping the real DuckDbStore on both
-    // graph and temporal slots — this matches what `openStore({backend:
-    // "duck"})` returns in production.
+    const graph = {
+      listEmbeddings: async function* () {
+        for (const row of rows) yield row;
+      },
+    } as unknown as Store["graph"];
+
     const composed: Store = {
-      backend: "duck",
-      graph: store,
-      temporal: store,
-      graphFile: dbPath,
+      graph,
+      temporal,
+      graphFile: ":memory:",
       temporalFile: dbPath,
       close: async () => {
-        /* test owns store lifecycle */
+        /* test owns lifecycle */
       },
     };
 
@@ -295,15 +216,10 @@ test("writeEmbeddingsSidecar — populated duck path is byte-identical across tw
 
     assert.equal(r1.written, true);
     assert.equal(r2.written, true);
-    assert.equal(r1.writerBackend, "duck-copy");
-    assert.equal(r2.writerBackend, "duck-copy");
-    assert.equal(r1.determinismClass, "strict");
     assert.equal(r1.rowCount, 100);
     assert.equal(r2.rowCount, 100);
-    assert.ok(
-      r1.pinsHint.duckdbVersion && r1.pinsHint.duckdbVersion.length > 0,
-      "duckdbVersion must be populated when sidecar is present",
-    );
+    assert.equal(r1.writerBackend, "duck-copy");
+    assert.ok(r1.pinsHint.duckdbVersion && r1.pinsHint.duckdbVersion.length > 0);
     assert.equal(r1.pinsHint.duckdbVersion, r2.pinsHint.duckdbVersion);
 
     const a = await readFile(outA);
@@ -315,23 +231,16 @@ test("writeEmbeddingsSidecar — populated duck path is byte-identical across tw
     );
     assert.equal(r1.fileHash, r2.fileHash);
   } finally {
-    await store.close();
+    await temporal.close();
     await rm(dir, { recursive: true, force: true });
   }
 });
 
-/**
- * Generate a deterministic Float32 vector. Uses a simple LCG seeded by
- * `(rowIndex, dimIndex)` so the same call returns the same vector across
- * runs — matches the byte-identity contract without dragging in a
- * crypto-grade RNG.
- */
 function deterministicVector(rowIndex: number, dim: number): Float32Array {
   const out = new Float32Array(dim);
   let s = (rowIndex * 2654435761) >>> 0;
   for (let i = 0; i < dim; i += 1) {
     s = (s * 1664525 + 1013904223) >>> 0;
-    // Map to roughly [-1, 1] with finite Float32 precision.
     out[i] = (s / 0xffffffff) * 2 - 1;
   }
   return out;
diff --git a/packages/pack/src/embeddings-sidecar.ts b/packages/pack/src/embeddings-sidecar.ts
index 18bc173b..5c99927d 100644
--- a/packages/pack/src/embeddings-sidecar.ts
+++ b/packages/pack/src/embeddings-sidecar.ts
@@ -1,55 +1,34 @@
 /**
  * BOM body item #7: Parquet embeddings sidecar.
  *
- * Sidecar emission lives in the pack layer, not in `@opencodehub/storage`.
- * The sidecar is a packaging concern: it consumes embeddings via the
- * portable {@link IGraphStore.listEmbeddings} method shipped by every
- * adapter and writes Parquet via the temporal store's DuckDB
- * `COPY ... TO ... (FORMAT PARQUET, COMPRESSION ZSTD)`. Third-party
- * graph adapters (AGE, Memgraph, Neo4j, Neptune) therefore do NOT
- * implement Parquet emission themselves — pack handles it from the
- * deterministic row stream.
- *
- * Backend dispatch:
- *
- *   - `backend === "duck"`: temporal IS the same DuckDB connection that
- *     owns the `embeddings` table. We call the @internal helper
- *     `DuckDbStore.exportEmbeddingsParquet` directly — it runs `COPY` over
- *     the existing rows and produces byte-identical output across runs.
- *     `determinismClass: "strict"`, `writerBackend: "duck-copy"`.
- *
- *   - `backend === "lbug"`: graph rows live in `@ladybugdb/core`; the paired
- *     temporal DuckDB has no embeddings table. v1 stamps
- *     `determinismClass: "degraded"`, `writerBackend: "absent"` and emits
- *     no file — lbug-only deployments accept `determinism_class:
- *     degraded` for v1. A future iteration can stage rows into the
- *     temporal store before COPY (or fall back to `@dsnp/parquetjs`)
- *     once the dep footprint is acceptable.
+ * Embeddings live in `graph.lbug` (the lbug graph backend). The sidecar
+ * stages rows through `temporal.duckdb` so we can lean on DuckDB's
+ * deterministic Parquet writer (`COPY (... ORDER BY ...) TO '...' (FORMAT
+ * PARQUET, COMPRESSION ZSTD)`). DuckDB v1.3+ rewrote its parquet writer
+ * to drop implicit timestamps so two consecutive runs produce
+ * byte-identical files.
  *
  * Determinism contract — non-negotiable, mirrored by the byte-identity
- * test in `embeddings-sidecar.test.ts` for the duck path:
+ * test in `embeddings-sidecar.test.ts`:
  *
- *   1. Row order = `node_id ASC, granularity ASC, chunk_index ASC`. The
- *      DuckDB COPY runs the inner SELECT to completion before writing,
- *      so the row groups in the resulting Parquet land in that order.
- *   2. ZSTD compression at the DuckDB default level. Two consecutive
- *      runs against the same store contents produce byte-identical
- *      `.parquet` files.
- *   3. DuckDB v1.3.0+ ("Ossivalis", 2025) rewrote the parquet writer to
- *      drop the implicit timestamps that previously broke byte-identity.
- *      The `created_by` metadata still carries the engine version, so
- *      the pack manifest pins `duckdbVersion` to the runtime
- *      `SELECT version()` result.
+ *   1. Row order = `node_id ASC, granularity ASC, chunk_index ASC`. lbug's
+ *      `listEmbeddings()` already iterates in that order; the COPY query
+ *      re-asserts it on the temp table for safety.
+ *   2. ZSTD compression at the DuckDB default level. Two runs against the
+ *      same store contents produce byte-identical Parquet files.
+ *   3. The pack manifest pins `duckdbVersion` from the runtime
+ *      `SELECT version()` result so the writer version is bound to the
+ *      sidecar.
  */
 
 import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
-import { DuckDbStore, type IGraphStore, type Store } from "@opencodehub/storage";
+import type { EmbeddingRow, Store } from "@opencodehub/storage";
 
 /**
  * Inputs to {@link writeEmbeddingsSidecar}. Takes a composed
- * {@link Store} (= `OpenStoreResult`) so the sidecar can dispatch on
- * backend and route through whichever adapter owns the embeddings.
+ * {@link Store} so the sidecar can stream from `store.graph` and route
+ * the COPY through `store.temporal`.
  */
 export interface SidecarOptions {
   /** Composed graph + temporal store. */
@@ -61,112 +40,50 @@ export interface SidecarOptions {
    */
   readonly outPath: string;
   /**
-   * Optional embedding-tier filter. When omitted the writer emits every
-   * row from the `embeddings` table in its native ordering. Reserved for
-   * future tier-specific packs; the duck-path COPY ignores it today.
+   * Optional embedding-tier filter. When omitted, every row in the
+   * embeddings table is emitted in its native ordering.
    */
   readonly granularity?: "symbol" | "file" | "community";
 }
 
-/**
- * Backend identifier for the writer that produced the sidecar (or
- * `"absent"` when no file was written).
- */
-export type SidecarWriterBackend = "duck-copy" | "parquetjs" | "absent";
+/** Backend identifier for the writer that produced the sidecar. */
+export type SidecarWriterBackend = "duck-copy" | "absent";
 
 /**
  * Determinism class stamped on the sidecar. `"strict"` when the writer
- * produces byte-identical output across runs; `"degraded"` otherwise
- * (e.g., lbug-only deployments where the pack writes no Parquet for v1).
+ * produces byte-identical output across runs.
  */
-export type SidecarDeterminismClass = "strict" | "degraded";
+export type SidecarDeterminismClass = "strict";
 
 /** Result of {@link writeEmbeddingsSidecar}. */
 export interface SidecarResult {
-  /** True when a Parquet file was written to `outPath`. */
   readonly written: boolean;
-  /** Number of `embeddings` rows materialized into the file (0 when not written). */
   readonly rowCount: number;
-  /** Strictness signal — `"degraded"` when the writer cannot emit a deterministic file. */
   readonly determinismClass: SidecarDeterminismClass;
-  /** Which writer produced the file, or `"absent"` when no file was written. */
   readonly writerBackend: SidecarWriterBackend;
-  /** Bytes written to disk; `0` when the sidecar is absent. */
   readonly bytesWritten: number;
-  /**
-   * Hint payload for `PackPins`. `duckdbVersion` is the runtime
-   * `SELECT version()` result from the DuckDB binding that wrote the
-   * file — pinning it stabilizes the cross-environment determinism
-   * contract because the parquet `created_by` metadata embeds this
-   * string. Undefined when no Parquet file was written.
-   */
   readonly pinsHint: { readonly duckdbVersion?: string };
-  /** sha256 hex of the written file. Undefined when no Parquet file was written. */
   readonly fileHash?: string;
 }
 
-/**
- * Structural type for stores that expose the @internal DuckDB COPY helper.
- * Pulled out so the runtime predicate stays explicit at the call site —
- * pack does not import the helper symbol itself, just narrows by
- * `instanceof DuckDbStore` plus a defensive duck-type check.
- */
-interface ParquetCopyCapableStore {
-  exportEmbeddingsParquet(
-    absOutPath: string,
-  ): Promise<{ readonly rowCount: number; readonly duckdbVersion: string }>;
-}
-
 /**
  * Write the optional Parquet embeddings sidecar.
  *
- * Returns `{ written: false, rowCount: 0, writerBackend: "absent", ... }`
- * when:
- *   - the `embeddings` table is empty (pack omits the BomItem);
- *   - the backend is `lbug` (v1 degraded path — no temporal embeddings
- *     table to COPY from).
- *
- * Returns `{ written: true, ..., fileHash, bytesWritten }` and writes the
- * Parquet file at `opts.outPath` when the duck-path emitter ran. The
- * caller (typically {@link generatePack}) appends the BomItem and pins
- * `duckdbVersion` from `pinsHint`.
+ * Returns `{written: false, writerBackend: "absent"}` for empty embeddings
+ * (no file on disk). Returns `{written: true, ..., fileHash}` and writes
+ * a deterministic Parquet file at `opts.outPath` otherwise. The temp table
+ * used to stage the COPY is dropped before the call returns.
  */
 export async function writeEmbeddingsSidecar(opts: SidecarOptions): Promise<SidecarResult> {
-  const { store, outPath } = opts;
-
-  // Locate the DuckDB-capable store. `backend === "duck"` → temporal IS
-  // the graph store; `backend === "lbug"` → the temporal DuckDB has no
-  // embeddings table, so the COPY helper is unreachable. The duck-type
-  // probe lets test fakes inject the helper without instantiating a
-  // real DuckDbStore (the byte-identity test does so).
-  const copyHelper = resolveCopyHelper(store);
-
-  if (copyHelper === undefined) {
-    // lbug path (or any community backend without DuckDB temporal): we
-    // cannot emit a deterministic Parquet file in v1. Stamp degraded so
-    // generatePack downgrades the manifest's determinism_class
-    // accordingly.
-    //
-    // Probe `listEmbeddings()` so callers and tests can still see whether
-    // any rows exist — the count signals to operators that the stamp is
-    // a deliberate v1 limitation rather than an empty table.
-    const rowCount = await countEmbeddings(store.graph, opts.granularity);
-    return {
-      written: false,
-      rowCount,
-      determinismClass: rowCount === 0 ? "strict" : "degraded",
-      writerBackend: "absent",
-      bytesWritten: 0,
-      pinsHint: {},
-    };
-  }
+  const { store, outPath, granularity } = opts;
 
-  const { rowCount, duckdbVersion } = await copyHelper.exportEmbeddingsParquet(outPath);
+  const stage = filterByGranularity(store.graph.listEmbeddings(), granularity);
+  const { rowCount, duckdbVersion } = await store.temporal.exportEmbeddingsToParquet(
+    stage,
+    outPath,
+  );
 
   if (rowCount === 0) {
-    // Empty embeddings means NO file on disk and no manifest entry.
-    // `determinismClass: "strict"` because absence is itself a
-    // deterministic outcome on the duck path.
     return {
       written: false,
       rowCount: 0,
@@ -177,11 +94,6 @@ export async function writeEmbeddingsSidecar(opts: SidecarOptions): Promise<Side
     };
   }
 
-  // Read the whole file for byte-identity hashing; derive size from the
-  // same buffer so `bytesWritten` and `fileHash` are taken from one read
-  // (no stat/read race). The typical pack target's sidecar is small
-  // (hundreds of KB to a few MB); the pack writer hashes every BOM body
-  // anyway.
   const bytes = await readFile(outPath);
   const fileHash = createHash("sha256").update(bytes).digest("hex");
   return {
@@ -195,69 +107,12 @@ export async function writeEmbeddingsSidecar(opts: SidecarOptions): Promise<Side
   };
 }
 
-/**
- * Return the @internal DuckDB COPY helper if the store exposes one.
- *
- * Lookup order:
- *   1. `store.graph` is a `DuckDbStore` (backend === "duck"). The graph
- *      view IS the embedding-owning DuckDB connection.
- *   2. `store.temporal` is a `DuckDbStore` AND its file holds the
- *      embeddings (backend === "duck"; same instance as graph in this
- *      arrangement).
- *   3. Either view duck-types as {@link ParquetCopyCapableStore} — used
- *      by the test fakes that simulate the COPY helper without a native
- *      DuckDB binding.
- *
- * Returns `undefined` when no helper is reachable. lbug-backed Stores
- * land here in v1 (their temporal DuckDB has no embeddings table; the
- * graph view is `GraphDbStore`).
- */
-function resolveCopyHelper(store: Store): ParquetCopyCapableStore | undefined {
-  if (store.graph instanceof DuckDbStore) {
-    return store.graph;
-  }
-  if (store.temporal instanceof DuckDbStore && store.backend === "duck") {
-    return store.temporal;
-  }
-  // Duck-type fallback for test fakes that attach `exportEmbeddingsParquet`
-  // to a plain object without instantiating a real DuckDbStore. We honor
-  // this only on the duck path — lbug deliberately resolves to absent.
-  if (store.backend === "duck") {
-    if (hasParquetCopy(store.graph)) return store.graph;
-    if (hasParquetCopy(store.temporal)) return store.temporal as unknown as ParquetCopyCapableStore;
-  }
-  return undefined;
-}
-
-function hasParquetCopy(store: unknown): store is ParquetCopyCapableStore {
-  if (store === null || typeof store !== "object") return false;
-  const fn = (store as { exportEmbeddingsParquet?: unknown }).exportEmbeddingsParquet;
-  return typeof fn === "function";
-}
-
-/**
- * Count rows in the embeddings stream so the degraded-path result still
- * carries an honest `rowCount`. Drains the iterator (which is the only
- * portable surface across both adapters) — a pure COUNT(*) shortcut isn't
- * on `IGraphStore` and adding one would widen the interface, which we
- * deliberately keep frozen at the `listEmbeddings` signature.
- *
- * Tolerant of test fakes that don't implement `listEmbeddings`: when the
- * method is missing we treat that as zero embeddings (the fake clearly
- * doesn't model the embeddings table). Real adapters always implement
- * it, so this guard never trips in production.
- */
-async function countEmbeddings(
-  graph: IGraphStore,
+async function* filterByGranularity(
+  rows: AsyncIterable<EmbeddingRow>,
   granularity: SidecarOptions["granularity"],
-): Promise<number> {
-  if (typeof (graph as { listEmbeddings?: unknown }).listEmbeddings !== "function") {
-    return 0;
-  }
-  let n = 0;
-  for await (const row of graph.listEmbeddings()) {
+): AsyncIterable<EmbeddingRow> {
+  for await (const row of rows) {
     if (granularity !== undefined && row.granularity !== granularity) continue;
-    n += 1;
+    yield row;
   }
-  return n;
 }
diff --git a/packages/pack/src/index.test.ts b/packages/pack/src/index.test.ts
index 60977765..c78ecb8d 100644
--- a/packages/pack/src/index.test.ts
+++ b/packages/pack/src/index.test.ts
@@ -133,6 +133,11 @@ function makeFixtureStore(): IGraphStore {
         (n): n is Extract<GraphNode, { kind: "Finding" }> => n.kind === "Finding",
       );
     },
+    // The fixture store has no embeddings; sidecar-absent tests rely on
+    // `listEmbeddings` being callable (and returning nothing).
+    listEmbeddings: async function* () {
+      // Empty generator — pack writes no sidecar.
+    },
   } as unknown as IGraphStore;
 }
 
@@ -368,23 +373,48 @@ test("E2E-G. sidecar absent — manifest.files[] does not list embeddings.parque
 test("E2E-H. sidecar present — manifest lists it; pins.duckdbVersion overrides", async () => {
   const dir = await tempDir();
   try {
-    // Inject a Store whose graph view duck-types the @internal COPY
-    // helper. `writeEmbeddingsSidecar` narrows on `backend === "duck"`
-    // and finds the helper attached to the graph view. The fake writes
-    // 4 magic bytes ("PAR1") to the path so we can verify the hash
-    // round-trips into manifest.files[].
+    // Inject a graph view that produces a deterministic embeddings stream
+    // and a temporal view whose `exportEmbeddingsToParquet` writes 4
+    // magic bytes ("PAR1") to the destination so the manifest hash is
+    // stable across runs.
     const baseStore = makeFixtureStore() as unknown as Record<string, unknown>;
-    baseStore["exportEmbeddingsParquet"] = async (absPath: string) => {
-      await (await import("node:fs/promises")).writeFile(
-        absPath,
-        new Uint8Array([0x50, 0x41, 0x52, 0x31]),
-      );
-      return { rowCount: 3, duckdbVersion: "v1.3.99-test" };
+    baseStore["listEmbeddings"] = async function* () {
+      yield {
+        nodeId: "fn:a",
+        granularity: "symbol" as const,
+        chunkIndex: 0,
+        vector: new Float32Array([0.1, 0.2]),
+        contentHash: "h-a",
+      };
+      yield {
+        nodeId: "fn:b",
+        granularity: "symbol" as const,
+        chunkIndex: 0,
+        vector: new Float32Array([0.3, 0.4]),
+        contentHash: "h-b",
+      };
+      yield {
+        nodeId: "fn:c",
+        granularity: "symbol" as const,
+        chunkIndex: 0,
+        vector: new Float32Array([0.5, 0.6]),
+        contentHash: "h-c",
+      };
+    };
+    const fakeTemporal = {
+      exportEmbeddingsToParquet: async (rows: AsyncIterable<unknown>, absPath: string) => {
+        let n = 0;
+        for await (const _row of rows) n += 1;
+        await (await import("node:fs/promises")).writeFile(
+          absPath,
+          new Uint8Array([0x50, 0x41, 0x52, 0x31]),
+        );
+        return { rowCount: n, duckdbVersion: "v1.3.99-test" };
+      },
     };
     const composedStore: Store = {
-      backend: "duck",
       graph: baseStore as unknown as IGraphStore,
-      temporal: baseStore as unknown as ITemporalStore,
+      temporal: fakeTemporal as unknown as ITemporalStore,
       graphFile: ":memory:",
       temporalFile: ":memory:",
       close: async () => {
diff --git a/packages/pack/src/index.ts b/packages/pack/src/index.ts
index 733155db..254eabf5 100644
--- a/packages/pack/src/index.ts
+++ b/packages/pack/src/index.ts
@@ -79,8 +79,9 @@ export interface GeneratePackInternalOpts {
   /**
    * Backwards-compatible escape hatch — tests can supply an
    * {@link IGraphStore} alone when they don't exercise the sidecar.
-   * Internally wrapped into a minimal {@link Store} that stamps
-   * `backend: "duck"` so the duck-type sidecar probe still works.
+   * Internally wrapped into a minimal {@link Store}; the temporal view is
+   * a typed alias of the graph value, sufficient for tests that only
+   * exercise the graph-tier reads.
    */
   readonly graphOnly?: IGraphStore;
   readonly commit?: string;
@@ -319,19 +320,27 @@ async function resolveStore(internal: GeneratePackInternalOpts, repoPath: string
 
 /**
  * Wrap a graph-only store so the legacy test seam (`internal.graphOnly`)
- * resolves into the `Store` shape `generatePack` now expects. Stamps
- * `backend: "duck"` so duck-typed test fakes that attach
- * `exportEmbeddingsParquet` to the graph view still hit the COPY helper
- * branch in `writeEmbeddingsSidecar`. The temporal view is the same
- * graph reference cast to `ITemporalStore`; the sidecar never calls
- * temporal methods on the duck path (the COPY helper lives on the graph
- * view in `backend === "duck"` mode), so the cast is safe in tests.
+ * resolves into the `Store` shape `generatePack` now expects. The temporal
+ * view is a stub that drains the embeddings stream and reports `rowCount:
+ * 0` — sufficient for tests that don't exercise sidecar emission.
  */
 function wrapGraphOnly(graph: IGraphStore): Store {
+  // Drain the stream without writing anything — graph-only tests don't
+  // exercise the COPY path, so reporting rowCount: 0 keeps the sidecar
+  // result `absent` regardless of how many embeddings the fake produces.
+  const stubTemporal = {
+    exportEmbeddingsToParquet: async (
+      rows: AsyncIterable<unknown>,
+    ): Promise<{ rowCount: number; duckdbVersion: string }> => {
+      for await (const _row of rows) {
+        // drain
+      }
+      return { rowCount: 0, duckdbVersion: "stub" };
+    },
+  };
   return {
-    backend: "duck",
     graph,
-    temporal: graph as unknown as Store["temporal"],
+    temporal: stubTemporal as unknown as Store["temporal"],
     graphFile: ":memory:",
     temporalFile: ":memory:",
     close: async () => {
diff --git a/packages/pack/src/pack-determinism.test.ts b/packages/pack/src/pack-determinism.test.ts
index 30e189ef..09b3c1f8 100644
--- a/packages/pack/src/pack-determinism.test.ts
+++ b/packages/pack/src/pack-determinism.test.ts
@@ -267,20 +267,52 @@ function makeRichFixtureStore(knobs: FixtureKnobs): IGraphStore {
         }));
     },
     listFindings: async () => findingNodes,
+    listEmbeddings: async function* () {
+      if (!knobs.withEmbeddings) return;
+      // Deterministic two-row stream — the temporal export fake below
+      // turns this into a 4-byte placeholder parquet.
+      yield {
+        nodeId: "fn:a",
+        granularity: "symbol" as const,
+        chunkIndex: 0,
+        vector: new Float32Array([0.1, 0.2]),
+        contentHash: "h-a",
+      };
+      yield {
+        nodeId: "fn:b",
+        granularity: "symbol" as const,
+        chunkIndex: 0,
+        vector: new Float32Array([0.3, 0.4]),
+        contentHash: "h-b",
+      };
+    },
   };
 
-  if (knobs.withEmbeddings) {
-    // Deterministic 4-byte parquet stand-in. Real DuckDB Parquet output is
-    // also byte-stable for the same input set on the same engine version;
-    // the test exercises the wiring path only.
-    store["exportEmbeddingsParquet"] = async (absPath: string): Promise<unknown> => {
+  return store as unknown as IGraphStore;
+}
+
+/**
+ * Fake `ITemporalStore` shim used by pack-determinism tests. The pack
+ * sidecar routes through `temporal.exportEmbeddingsToParquet`; the real
+ * DuckDB binding is irrelevant to these wiring tests so we drain the
+ * stream and write a deterministic 4-byte parquet stand-in.
+ */
+function makeFakeTemporalForPack(knobs: FixtureKnobs): unknown {
+  return {
+    exportEmbeddingsToParquet: async (
+      rows: AsyncIterable<unknown>,
+      absPath: string,
+    ): Promise<{ rowCount: number; duckdbVersion: string }> => {
+      let n = 0;
+      for await (const _row of rows) n += 1;
+      if (!knobs.withEmbeddings || n === 0) {
+        return { rowCount: 0, duckdbVersion: "v1.3.99-test" };
+      }
       const fs = await import("node:fs/promises");
       await fs.writeFile(absPath, new Uint8Array([0x50, 0x41, 0x52, 0x31]));
-      return { rowCount: 2, duckdbVersion: "v1.3.99-test" };
-    };
-  }
-
-  return store as unknown as IGraphStore;
+      return { rowCount: n, duckdbVersion: "v1.3.99-test" };
+    },
+  };
 }
 
 // ---------------------------------------------------------------------------
@@ -338,9 +370,8 @@ async function runVariant(outDir: string, knobs: FixtureKnobs): Promise<{ packHa
   // backend:"duck" Store so the sidecar narrows correctly. V1/V3/V4
   // never invoke the helper; the wrapper just exposes the graph view.
   const composedStore: Store = {
-    backend: "duck",
     graph: fakeGraph,
-    temporal: fakeGraph as unknown as ITemporalStore,
+    temporal: makeFakeTemporalForPack(knobs) as unknown as ITemporalStore,
     graphFile: ":memory:",
     temporalFile: ":memory:",
     close: async () => {
diff --git a/packages/search/src/bm25.test.ts b/packages/search/src/bm25.test.ts
index c62b7c4b..421c8633 100644
--- a/packages/search/src/bm25.test.ts
+++ b/packages/search/src/bm25.test.ts
@@ -32,7 +32,7 @@ interface StubCall {
 }
 
 class StubStore implements IGraphStore {
-  readonly dialect: GraphDialect = "none";
+  readonly dialect: GraphDialect = "cypher";
   readonly calls: StubCall[] = [];
   results: SearchResult[] = [];
 
diff --git a/packages/search/src/hybrid.test.ts b/packages/search/src/hybrid.test.ts
index b2818cd2..409e621a 100644
--- a/packages/search/src/hybrid.test.ts
+++ b/packages/search/src/hybrid.test.ts
@@ -31,7 +31,7 @@ import { hybridSearch } from "./hybrid.js";
 import type { Embedder } from "./types.js";
 
 class StubStore implements IGraphStore {
-  readonly dialect: GraphDialect = "none";
+  readonly dialect: GraphDialect = "cypher";
   searchRows: SearchResult[] = [];
   vectorRows: VectorResult[] = [];
   /**
diff --git a/packages/storage/package.json b/packages/storage/package.json
index 41ee55a1..ea26a78f 100644
--- a/packages/storage/package.json
+++ b/packages/storage/package.json
@@ -37,7 +37,7 @@
   ],
   "scripts": {
     "build": "tsc -b",
-    "test": "node --test ./dist/**/*.test.js",
+    "test": "node --test --test-concurrency=1 ./dist/**/*.test.js",
     "clean": "rm -rf dist *.tsbuildinfo"
   },
   "dependencies": {
diff --git a/packages/storage/src/duckdb-adapter.test.ts b/packages/storage/src/duckdb-adapter.test.ts
index c11fd3f5..679863c6 100644
--- a/packages/storage/src/duckdb-adapter.test.ts
+++ b/packages/storage/src/duckdb-adapter.test.ts
@@ -3,1106 +3,17 @@ import { mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { test } from "node:test";
-import {
-  type GraphNode,
-  graphHash,
-  KnowledgeGraph,
-  makeNodeId,
-  type NodeId,
-} from "@opencodehub/core-types";
 import { DuckDbStore } from "./duckdb-adapter.js";
-import type { StoreMeta } from "./interface.js";
-import { assertIGraphStoreConformance } from "./test-utils/conformance.js";
 
 async function scratchDbPath(): Promise<string> {
   const dir = await mkdtemp(join(tmpdir(), "och-storage-duck-"));
-  return join(dir, "graph.duckdb");
+  return join(dir, "temporal.duckdb");
 }
 
 // ---------------------------------------------------------------------------
-// Fixture builders
+// Cochanges
 // ---------------------------------------------------------------------------
 
-function buildSmallGraph(): KnowledgeGraph {
-  const g = new KnowledgeGraph();
-
-  const fileA = makeNodeId("File", "src/a.ts", "a.ts");
-  const fileB = makeNodeId("File", "src/b.ts", "b.ts");
-  // Note: we intentionally omit fields (e.g. `language`, `contentHash`) that
-  // the fixture doesn't rely on for the determinism assertion. The schema
-  // stores a documented subset of node fields — rebuildGraphFromStore reads
-  // the same subset back, so graphHash is stable across the round-trip.
-  g.addNode({ id: fileA, kind: "File", name: "a.ts", filePath: "src/a.ts" });
-  g.addNode({ id: fileB, kind: "File", name: "b.ts", filePath: "src/b.ts" });
-
-  const funcs: NodeId[] = [];
-  for (let i = 0; i < 8; i += 1) {
-    const file = i % 2 === 0 ? "src/a.ts" : "src/b.ts";
-    const id = makeNodeId("Function", file, `fn_${i}`, { parameterCount: i % 3 });
-    funcs.push(id);
-    g.addNode({
-      id,
-      kind: "Function",
-      name: `fn_${i}`,
-      filePath: file,
-      startLine: 10 + i,
-      endLine: 20 + i,
-      signature: `function fn_${i}(${"x,".repeat(i % 3).replace(/,$/, "")})`,
-      parameterCount: i % 3,
-      isExported: i % 2 === 0,
-    });
-  }
-
-  // Edges: DEFINES from each file to its functions, plus a CALLS chain.
-  for (let i = 0; i < funcs.length; i += 1) {
-    const from = i % 2 === 0 ? fileA : fileB;
-    g.addEdge({ from, to: funcs[i] as NodeId, type: "DEFINES", confidence: 1.0 });
-  }
-  for (let i = 0; i + 1 < funcs.length; i += 1) {
-    g.addEdge({
-      from: funcs[i] as NodeId,
-      to: funcs[i + 1] as NodeId,
-      type: "CALLS",
-      confidence: 0.9,
-    });
-  }
-
-  return g;
-}
-
-// Read all rows back from DuckDB and rebuild a KnowledgeGraph so we can
-// compare logical hashes across different writes.
-// Column → GraphNode key mapping used by the hash round-trip helper. Kept
-// flat (no kind-specific logic) because the fixture graph only uses File and
-// Function nodes, which share a subset of these fields.
-const NODE_COLUMN_MAP: readonly (readonly [string, string, "number" | "string" | "boolean"])[] = [
-  ["start_line", "startLine", "number"],
-  ["end_line", "endLine", "number"],
-  ["is_exported", "isExported", "boolean"],
-  ["signature", "signature", "string"],
-  ["parameter_count", "parameterCount", "number"],
-  ["return_type", "returnType", "string"],
-  ["declared_type", "declaredType", "string"],
-  ["owner", "owner", "string"],
-  ["content_hash", "contentHash", "string"],
-];
-
-async function rebuildGraphFromStore(store: DuckDbStore): Promise<KnowledgeGraph> {
-  const nodeRows = await store.query(
-    `SELECT id, kind, name, file_path, start_line, end_line, is_exported, signature,
-            parameter_count, return_type, declared_type, owner, content_hash
-     FROM nodes ORDER BY id`,
-  );
-  const edgeRows = await store.query(
-    "SELECT id, from_id, to_id, type, confidence, reason, step FROM relations ORDER BY id",
-  );
-  const g = new KnowledgeGraph();
-  for (const row of nodeRows) {
-    const id = String(row["id"]) as NodeId;
-    const kind = String(row["kind"]);
-    const base: Record<string, unknown> = {
-      id,
-      kind,
-      name: String(row["name"] ?? ""),
-      filePath: String(row["file_path"] ?? ""),
-    };
-    for (const [col, key, kind2] of NODE_COLUMN_MAP) {
-      const v = row[col];
-      if (v === null || v === undefined) continue;
-      if (kind2 === "number") base[key] = Number(v);
-      else if (kind2 === "boolean") base[key] = Boolean(v);
-      else base[key] = String(v);
-    }
-    g.addNode(base as unknown as GraphNode);
-  }
-  for (const row of edgeRows) {
-    const step = Number(row["step"] ?? 0);
-    g.addEdge({
-      from: String(row["from_id"]) as NodeId,
-      to: String(row["to_id"]) as NodeId,
-      type: row["type"] as "CALLS" | "DEFINES",
-      confidence: Number(row["confidence"] ?? 0),
-      ...(row["reason"] !== null && row["reason"] !== undefined
-        ? { reason: String(row["reason"]) }
-        : {}),
-      ...(step !== 0 ? { step } : {}),
-    });
-  }
-  return g;
-}
-
-// ---------------------------------------------------------------------------
-// Core lifecycle
-// ---------------------------------------------------------------------------
-
-test("open → createSchema → bulkLoad → counts match", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    const graph = buildSmallGraph();
-    const stats = await store.bulkLoad(graph);
-    assert.equal(stats.nodeCount, graph.nodeCount());
-    assert.equal(stats.edgeCount, graph.edgeCount());
-    const nodeCountRow = await store.query("SELECT COUNT(*) AS n FROM nodes");
-    const edgeCountRow = await store.query("SELECT COUNT(*) AS n FROM relations");
-    assert.equal(Number(nodeCountRow[0]?.["n"]), graph.nodeCount());
-    assert.equal(Number(edgeCountRow[0]?.["n"]), graph.edgeCount());
-  } finally {
-    await store.close();
-  }
-});
-
-test("reopen read-only → same row counts", async () => {
-  const dbPath = await scratchDbPath();
-  const writer = new DuckDbStore(dbPath);
-  await writer.open();
-  await writer.createSchema();
-  const graph = buildSmallGraph();
-  const originalNodes = graph.nodeCount();
-  const originalEdges = graph.edgeCount();
-  await writer.bulkLoad(graph);
-  await writer.close();
-
-  const reader = new DuckDbStore(dbPath, { readOnly: true });
-  await reader.open();
-  try {
-    const n = await reader.query("SELECT COUNT(*) AS n FROM nodes");
-    const e = await reader.query("SELECT COUNT(*) AS n FROM relations");
-    assert.equal(Number(n[0]?.["n"]), originalNodes);
-    assert.equal(Number(e[0]?.["n"]), originalEdges);
-  } finally {
-    await reader.close();
-  }
-});
-
-test("read-only connection rejects CREATE TABLE", async () => {
-  const dbPath = await scratchDbPath();
-  const writer = new DuckDbStore(dbPath);
-  await writer.open();
-  await writer.createSchema();
-  await writer.close();
-
-  const reader = new DuckDbStore(dbPath, { readOnly: true });
-  await reader.open();
-  try {
-    // Bypass the guard by checking the engine itself; the guard test suite
-    // covers guard rejection separately. We push a raw run through the
-    // adapter's query() API which routes through the guard, so instead reach
-    // in and run directly via the connection by re-opening + writing a table.
-    // A simpler check: the guard should reject CREATE upfront.
-    await assert.rejects(async () => {
-      await reader.query("CREATE TABLE x (a INT)");
-    }, /CREATE/);
-  } finally {
-    await reader.close();
-  }
-});
-
-// ---------------------------------------------------------------------------
-// Determinism
-// ---------------------------------------------------------------------------
-
-test("logical graphHash matches across two independent bulk loads", async () => {
-  const graph = buildSmallGraph();
-  const originalHash = graphHash(graph);
-
-  const pathA = await scratchDbPath();
-  const storeA = new DuckDbStore(pathA);
-  await storeA.open();
-  await storeA.createSchema();
-  await storeA.bulkLoad(graph);
-  const rebuiltA = await rebuildGraphFromStore(storeA);
-  await storeA.close();
-
-  const pathB = await scratchDbPath();
-  const storeB = new DuckDbStore(pathB);
-  await storeB.open();
-  await storeB.createSchema();
-  await storeB.bulkLoad(graph);
-  const rebuiltB = await rebuildGraphFromStore(storeB);
-  await storeB.close();
-
-  const hashA = graphHash(rebuiltA);
-  const hashB = graphHash(rebuiltB);
-  assert.equal(hashA, hashB, "hashes across the two stores must match");
-  assert.equal(hashA, originalHash, "hash after round-trip must match the original graph hash");
-});
-
-// ---------------------------------------------------------------------------
-// FTS / BM25
-// ---------------------------------------------------------------------------
-
-test("search: BM25 index finds a distinct symbol name", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    const g = new KnowledgeGraph();
-    const ids = [
-      makeNodeId("Function", "src/user.ts", "parseUserProfile"),
-      makeNodeId("Function", "src/view.ts", "renderMarkdownView"),
-      makeNodeId("Function", "src/router.ts", "registerHttpRoute"),
-    ];
-    const names = ["parseUserProfile", "renderMarkdownView", "registerHttpRoute"];
-    for (let i = 0; i < ids.length; i += 1) {
-      g.addNode({
-        id: ids[i] as NodeId,
-        kind: "Function",
-        name: names[i] ?? "",
-        filePath: `src/f${i}.ts`,
-        signature: `function ${names[i]}()`,
-      });
-    }
-    await store.bulkLoad(g);
-
-    const results = await store.search({ text: "parseUserProfile", limit: 5 });
-    assert.ok(results.length >= 1, "search should return at least one row");
-    const top = results[0];
-    assert.ok(top, "top row exists");
-    assert.equal(top.nodeId, ids[0]);
-    assert.equal(top.name, "parseUserProfile");
-    assert.ok(top.score > 0, "BM25 score should be positive");
-  } finally {
-    await store.close();
-  }
-});
-
-test("search: identical queries return deterministic order when scores tie", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    const g = new KnowledgeGraph();
-    // Seven functions with the same name in different files will all match
-    // the same BM25 query string and are likely to tie on score. The
-    // tiebreaker in ORDER BY (id ASC, file_path ASC, name ASC) must produce
-    // an identical ordering across repeated calls.
-    const files = [
-      "src/a/alpha.ts",
-      "src/b/alpha.ts",
-      "src/c/alpha.ts",
-      "src/d/alpha.ts",
-      "src/e/alpha.ts",
-      "src/f/alpha.ts",
-      "src/g/alpha.ts",
-    ];
-    for (const file of files) {
-      const id = makeNodeId("Function", file, "eventLoopCycle");
-      g.addNode({
-        id,
-        kind: "Function",
-        name: "eventLoopCycle",
-        filePath: file,
-        signature: "function eventLoopCycle()",
-      });
-    }
-    await store.bulkLoad(g);
-
-    const run1 = await store.search({ text: "eventLoopCycle", limit: 10 });
-    const run2 = await store.search({ text: "eventLoopCycle", limit: 10 });
-    const run3 = await store.search({ text: "eventLoopCycle", limit: 10 });
-
-    assert.ok(run1.length >= files.length, "should return all matching rows");
-    const ids1 = run1.map((r) => r.nodeId);
-    const ids2 = run2.map((r) => r.nodeId);
-    const ids3 = run3.map((r) => r.nodeId);
-    assert.deepEqual(ids1, ids2, "back-to-back search runs must return identical order");
-    assert.deepEqual(ids2, ids3, "three consecutive runs must all agree");
-
-    // Among rows that tie on score, the tiebreakers must produce a
-    // lexicographic order: sorting by (id, file_path, name) reproduces the
-    // actual result order within each score bucket.
-    type Row = (typeof run1)[number];
-    const byScore = new Map<number, Row[]>();
-    for (const r of run1) {
-      const bucket = byScore.get(r.score) ?? [];
-      bucket.push(r);
-      byScore.set(r.score, bucket);
-    }
-    for (const bucket of byScore.values()) {
-      if (bucket.length < 2) continue;
-      const sorted = [...bucket].sort((a, b) => {
-        if (a.nodeId !== b.nodeId) return a.nodeId < b.nodeId ? -1 : 1;
-        if (a.filePath !== b.filePath) return a.filePath < b.filePath ? -1 : 1;
-        if (a.name !== b.name) return a.name < b.name ? -1 : 1;
-        return 0;
-      });
-      assert.deepEqual(
-        bucket.map((r) => r.nodeId),
-        sorted.map((r) => r.nodeId),
-        "tied-score rows must be ordered by (id, file_path, name) ascending",
-      );
-    }
-  } finally {
-    await store.close();
-  }
-});
-
-// ---------------------------------------------------------------------------
-// Granularity migration + filter tests (P03)
-// ---------------------------------------------------------------------------
-
-test("embeddings rows default to granularity='symbol' when not set", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath, { embeddingDim: 4 });
-  await store.open();
-  try {
-    await store.createSchema();
-    const g = new KnowledgeGraph();
-    const id = makeNodeId("Function", "src/a.ts", "a");
-    g.addNode({
-      id,
-      kind: "Function",
-      name: "a",
-      filePath: "src/a.ts",
-    });
-    await store.bulkLoad(g);
-    // Legacy caller: no `granularity` field. The adapter passes an explicit
-    // 'symbol' fallback so the row always has a tier on disk.
-    await store.upsertEmbeddings([
-      {
-        nodeId: id,
-        chunkIndex: 0,
-        vector: new Float32Array([1, 0, 0, 0]),
-        contentHash: "h",
-      },
-    ]);
-    const rows = await store.query("SELECT granularity FROM embeddings WHERE node_id = ?", [id]);
-    assert.equal(rows.length, 1);
-    assert.equal(rows[0]?.["granularity"], "symbol");
-  } finally {
-    await store.close();
-  }
-});
-
-test("vectorSearch with granularity filter restricts to that tier", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath, { embeddingDim: 4 });
-  await store.open();
-  const warning = store.getExtensionWarning();
-  if (warning?.startsWith("No HNSW")) {
-    await store.close();
-    assert.ok(true, "no HNSW extension available — test skipped");
-    return;
-  }
-  try {
-    await store.createSchema();
-    const g = new KnowledgeGraph();
-    const fnId = makeNodeId("Function", "src/a.ts", "a");
-    const fileId = makeNodeId("File", "src/a.ts", "src/a.ts");
-    const commId = makeNodeId("Community", "<global>", "community-0");
-    g.addNode({ id: fnId, kind: "Function", name: "a", filePath: "src/a.ts" });
-    g.addNode({ id: fileId, kind: "File", name: "a.ts", filePath: "src/a.ts" });
-    g.addNode({
-      id: commId,
-      kind: "Community",
-      name: "community-0",
-      filePath: "<global>",
-      symbolCount: 3,
-      cohesion: 1,
-    });
-    await store.bulkLoad(g);
-    await store.upsertEmbeddings([
-      {
-        nodeId: fnId,
-        granularity: "symbol",
-        chunkIndex: 0,
-        vector: new Float32Array([1, 0, 0, 0]),
-        contentHash: "h-sym",
-      },
-      {
-        nodeId: fileId,
-        granularity: "file",
-        chunkIndex: 0,
-        vector: new Float32Array([0.9, 0.1, 0, 0]),
-        contentHash: "h-file",
-      },
-      {
-        nodeId: commId,
-        granularity: "community",
-        chunkIndex: 0,
-        vector: new Float32Array([0.8, 0.2, 0, 0]),
-        contentHash: "h-comm",
-      },
-    ]);
-
-    const fileHits = await store.vectorSearch({
-      vector: new Float32Array([1, 0, 0, 0]),
-      granularity: "file",
-      limit: 10,
-    });
-    assert.equal(fileHits.length, 1);
-    assert.equal(fileHits[0]?.nodeId, fileId);
-
-    const commHits = await store.vectorSearch({
-      vector: new Float32Array([1, 0, 0, 0]),
-      granularity: "community",
-      limit: 10,
-    });
-    assert.equal(commHits.length, 1);
-    assert.equal(commHits[0]?.nodeId, commId);
-
-    const multi = await store.vectorSearch({
-      vector: new Float32Array([1, 0, 0, 0]),
-      granularity: ["symbol", "community"],
-      limit: 10,
-    });
-    const ids = new Set(multi.map((r) => r.nodeId));
-    assert.ok(ids.has(fnId));
-    assert.ok(ids.has(commId));
-    assert.ok(!ids.has(fileId));
-  } finally {
-    await store.close();
-  }
-});
-
-// ---------------------------------------------------------------------------
-// listEmbeddingHashes — content-hash skip helper
-// ---------------------------------------------------------------------------
-
-test("listEmbeddingHashes returns an empty Map on a fresh database", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath, { embeddingDim: 4 });
-  await store.open();
-  try {
-    await store.createSchema();
-    const hashes = await store.listEmbeddingHashes();
-    assert.ok(hashes instanceof Map, "returns a Map instance");
-    assert.equal(hashes.size, 0, "empty database yields empty map");
-  } finally {
-    await store.close();
-  }
-});
-
-test("listEmbeddingHashes returns one entry per (granularity, node_id, chunk_index)", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath, { embeddingDim: 4 });
-  await store.open();
-  try {
-    await store.createSchema();
-    const g = new KnowledgeGraph();
-    const fnId = makeNodeId("Function", "src/a.ts", "a");
-    const fileId = makeNodeId("File", "src/a.ts", "src/a.ts");
-    const commId = makeNodeId("Community", "<global>", "community-0");
-    g.addNode({ id: fnId, kind: "Function", name: "a", filePath: "src/a.ts" });
-    g.addNode({ id: fileId, kind: "File", name: "a.ts", filePath: "src/a.ts" });
-    g.addNode({
-      id: commId,
-      kind: "Community",
-      name: "community-0",
-      filePath: "<global>",
-      symbolCount: 1,
-      cohesion: 1,
-    });
-    await store.bulkLoad(g);
-    await store.upsertEmbeddings([
-      {
-        nodeId: fnId,
-        granularity: "symbol",
-        chunkIndex: 0,
-        vector: new Float32Array([1, 0, 0, 0]),
-        contentHash: "h-sym-0",
-      },
-      {
-        nodeId: fnId,
-        granularity: "symbol",
-        chunkIndex: 1,
-        vector: new Float32Array([1, 0, 0, 0]),
-        contentHash: "h-sym-1",
-      },
-      {
-        nodeId: fileId,
-        granularity: "file",
-        chunkIndex: 0,
-        vector: new Float32Array([0.9, 0.1, 0, 0]),
-        contentHash: "h-file",
-      },
-      {
-        nodeId: commId,
-        granularity: "community",
-        chunkIndex: 0,
-        vector: new Float32Array([0.8, 0.2, 0, 0]),
-        contentHash: "h-comm",
-      },
-    ]);
-
-    const hashes = await store.listEmbeddingHashes();
-    assert.equal(hashes.size, 4, "one entry per composite-key row");
-    assert.equal(hashes.get(`symbol\0${fnId}\0${0}`), "h-sym-0");
-    assert.equal(hashes.get(`symbol\0${fnId}\0${1}`), "h-sym-1");
-    assert.equal(hashes.get(`file\0${fileId}\0${0}`), "h-file");
-    assert.equal(hashes.get(`community\0${commId}\0${0}`), "h-comm");
-  } finally {
-    await store.close();
-  }
-});
-
-test("listEmbeddingHashes reflects upsert overwrites by composite key", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath, { embeddingDim: 4 });
-  await store.open();
-  try {
-    await store.createSchema();
-    const g = new KnowledgeGraph();
-    const fnId = makeNodeId("Function", "src/a.ts", "a");
-    g.addNode({ id: fnId, kind: "Function", name: "a", filePath: "src/a.ts" });
-    await store.bulkLoad(g);
-
-    await store.upsertEmbeddings([
-      {
-        nodeId: fnId,
-        granularity: "symbol",
-        chunkIndex: 0,
-        vector: new Float32Array([1, 0, 0, 0]),
-        contentHash: "original",
-      },
-    ]);
-    let hashes = await store.listEmbeddingHashes();
-    assert.equal(hashes.get(`symbol\0${fnId}\0${0}`), "original");
-
-    // Upsert the same PK with a new hash — listEmbeddingHashes must reflect it.
-    await store.upsertEmbeddings([
-      {
-        nodeId: fnId,
-        granularity: "symbol",
-        chunkIndex: 0,
-        vector: new Float32Array([0, 1, 0, 0]),
-        contentHash: "updated",
-      },
-    ]);
-    hashes = await store.listEmbeddingHashes();
-    assert.equal(hashes.size, 1, "upsert replaces the row — not duplicated");
-    assert.equal(hashes.get(`symbol\0${fnId}\0${0}`), "updated");
-  } finally {
-    await store.close();
-  }
-});
-
-// ---------------------------------------------------------------------------
-// Vector search
-// ---------------------------------------------------------------------------
-
-test("vectorSearch with HNSW filters by WHERE clause", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath, { embeddingDim: 4 });
-  await store.open();
-
-  // If neither hnsw_acorn nor vss loaded (e.g. offline), the vector search is
-  // disabled and the test skips rather than fails — see anti-goal in the PRD.
-  const warning = store.getExtensionWarning();
-  if (warning?.startsWith("No HNSW")) {
-    await store.close();
-    assert.ok(true, "no HNSW extension available — test skipped");
-    return;
-  }
-
-  try {
-    await store.createSchema();
-    const g = new KnowledgeGraph();
-    const ids: NodeId[] = [];
-    const languages = ["python", "python", "python", "javascript", "javascript"];
-    const vectors = [
-      [1.0, 0.0, 0.0, 0.0],
-      [0.9, 0.1, 0.0, 0.0],
-      [0.8, 0.2, 0.0, 0.0],
-      [0.0, 1.0, 0.0, 0.0],
-      [0.0, 0.9, 0.1, 0.0],
-    ];
-    for (let i = 0; i < 5; i += 1) {
-      const id = makeNodeId("File", `src/f${i}.${i < 3 ? "py" : "js"}`, `f${i}`);
-      ids.push(id);
-      g.addNode({
-        id,
-        kind: "File",
-        name: `f${i}`,
-        filePath: `src/f${i}.${i < 3 ? "py" : "js"}`,
-        language: languages[i] ?? "",
-      });
-    }
-    await store.bulkLoad(g);
-    await store.upsertEmbeddings(
-      ids.map((id, i) => ({
-        nodeId: id,
-        chunkIndex: 0,
-        vector: new Float32Array(vectors[i] ?? []),
-        contentHash: `h${i}`,
-      })),
-    );
-
-    const results = await store.vectorSearch({
-      vector: new Float32Array([1.0, 0.0, 0.0, 0.0]),
-      whereClause: "n.file_path LIKE ?",
-      params: ["%.py"],
-      limit: 10,
-    });
-    assert.ok(results.length <= 3, `filter should cap results at 3, got ${results.length}`);
-    for (const r of results) {
-      assert.ok(
-        r.nodeId.includes(".py"),
-        `filtered result ${r.nodeId} should come from a python file`,
-      );
-    }
-    const first = results[0];
-    assert.ok(first, "at least one match expected");
-    assert.equal(first.nodeId, ids[0], "nearest should be the identical vector");
-  } finally {
-    await store.close();
-  }
-});
-
-// ---------------------------------------------------------------------------
-// Traversal
-// ---------------------------------------------------------------------------
-
-test("traverse (down): reaches transitive children within depth bound", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    const g = new KnowledgeGraph();
-    const a = makeNodeId("Function", "x.ts", "A");
-    const b = makeNodeId("Function", "x.ts", "B");
-    const c = makeNodeId("Function", "x.ts", "C");
-    const d = makeNodeId("Function", "x.ts", "D");
-    for (const [id, name] of [
-      [a, "A"],
-      [b, "B"],
-      [c, "C"],
-      [d, "D"],
-    ] as const) {
-      g.addNode({ id, kind: "Function", name, filePath: "x.ts" });
-    }
-    g.addEdge({ from: a, to: b, type: "CALLS", confidence: 1.0 });
-    g.addEdge({ from: b, to: c, type: "CALLS", confidence: 1.0 });
-    g.addEdge({ from: c, to: d, type: "CALLS", confidence: 1.0 });
-    await store.bulkLoad(g);
-
-    const downDepth2 = await store.traverse({
-      startId: a,
-      direction: "down",
-      maxDepth: 2,
-      relationTypes: ["CALLS"],
-    });
-    const reachedIds = new Set(downDepth2.map((r) => r.nodeId));
-    assert.ok(reachedIds.has(b), "B should be reached at depth 1");
-    assert.ok(reachedIds.has(c), "C should be reached at depth 2");
-    assert.ok(!reachedIds.has(d), "D must be pruned by depth bound");
-
-    const upFromD = await store.traverse({
-      startId: d,
-      direction: "up",
-      maxDepth: 3,
-      relationTypes: ["CALLS"],
-    });
-    const upIds = new Set(upFromD.map((r) => r.nodeId));
-    assert.ok(upIds.has(c) && upIds.has(b) && upIds.has(a), "up traversal reaches A");
-  } finally {
-    await store.close();
-  }
-});
-
-test("traverse (both): reaches upstream and downstream neighbors without duplicates", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    const g = new KnowledgeGraph();
-    // Graph: A -> B -> C, and D -> B (so B has an upstream caller D besides A).
-    const a = makeNodeId("Function", "x.ts", "A");
-    const b = makeNodeId("Function", "x.ts", "B");
-    const c = makeNodeId("Function", "x.ts", "C");
-    const d = makeNodeId("Function", "x.ts", "D");
-    for (const [id, name] of [
-      [a, "A"],
-      [b, "B"],
-      [c, "C"],
-      [d, "D"],
-    ] as const) {
-      g.addNode({ id, kind: "Function", name, filePath: "x.ts" });
-    }
-    g.addEdge({ from: a, to: b, type: "CALLS", confidence: 1.0 });
-    g.addEdge({ from: b, to: c, type: "CALLS", confidence: 1.0 });
-    g.addEdge({ from: d, to: b, type: "CALLS", confidence: 1.0 });
-    await store.bulkLoad(g);
-
-    const both = await store.traverse({
-      startId: b,
-      direction: "both",
-      maxDepth: 2,
-      relationTypes: ["CALLS"],
-    });
-    const ids = both.map((r) => r.nodeId);
-    const idSet = new Set(ids);
-    // Forward reach: C (B -> C) and backward reach: A, D (A -> B, D -> B).
-    assert.ok(idSet.has(a), "both traversal must reach upstream caller A");
-    assert.ok(idSet.has(c), "both traversal must reach downstream callee C");
-    assert.ok(idSet.has(d), "both traversal must reach upstream caller D");
-    // USING KEY collapses duplicate visits so each node_id appears at most once.
-    assert.equal(ids.length, idSet.size, "no duplicate node_ids in traverse result");
-    // Start node must not appear (WHERE depth > 0).
-    assert.ok(!idSet.has(b), "start node B must be excluded from result set");
-  } finally {
-    await store.close();
-  }
-});
-
-// ---------------------------------------------------------------------------
-// Meta + health
-// ---------------------------------------------------------------------------
-
-test("setMeta / getMeta round-trips including stats", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    const meta: StoreMeta = {
-      schemaVersion: "1.0.0",
-      lastCommit: "deadbeef",
-      indexedAt: "2026-04-18T09:00:00Z",
-      nodeCount: 100,
-      edgeCount: 250,
-      stats: { files: 12, functions: 88 },
-    };
-    await store.setMeta(meta);
-    const readBack = await store.getMeta();
-    assert.deepEqual(readBack, meta);
-  } finally {
-    await store.close();
-  }
-});
-
-test("healthCheck returns ok after open", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    const h = await store.healthCheck();
-    assert.equal(h.ok, true);
-  } finally {
-    await store.close();
-  }
-});
-
-// ---------------------------------------------------------------------------
-// v1.1 NodeKinds round-trip
-// ---------------------------------------------------------------------------
-
-test("bulkLoad stores Finding / Dependency / Operation / Contributor / ProjectProfile columns", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    const g = new KnowledgeGraph();
-
-    const findingId = makeNodeId("Finding", "src/a.ts", "rule-x#1");
-    g.addNode({
-      id: findingId,
-      kind: "Finding",
-      name: "rule-x#1",
-      filePath: "src/a.ts",
-      startLine: 10,
-      endLine: 12,
-      ruleId: "rule-x",
-      severity: "warning",
-      scannerId: "semgrep",
-      message: "Possible XSS sink",
-      propertiesBag: { cwe: "CWE-79", confidence: "HIGH" },
-    } as unknown as GraphNode);
-
-    const depId = makeNodeId("Dependency", "package-lock.json", "react@18.2.0");
-    g.addNode({
-      id: depId,
-      kind: "Dependency",
-      name: "react",
-      filePath: "package-lock.json",
-      version: "18.2.0",
-      ecosystem: "npm",
-      lockfileSource: "package-lock.json",
-      license: "MIT",
-    } as unknown as GraphNode);
-
-    const opId = makeNodeId("Operation", "openapi.yaml", "GET /users/{id}");
-    g.addNode({
-      id: opId,
-      kind: "Operation",
-      name: "getUserById",
-      filePath: "openapi.yaml",
-      method: "GET",
-      path: "/users/{id}",
-      summary: "Fetch one user by id",
-      operationId: "getUserById",
-    } as unknown as GraphNode);
-
-    const contribId = makeNodeId("Contributor", "", "7a0f...");
-    g.addNode({
-      id: contribId,
-      kind: "Contributor",
-      name: "Alice Example",
-      filePath: "",
-      emailHash: "7a0fcafedeadbeef",
-      emailPlain: "alice@example.com",
-    } as unknown as GraphNode);
-
-    const profileId = makeNodeId("ProjectProfile", "", "repo");
-    g.addNode({
-      id: profileId,
-      kind: "ProjectProfile",
-      name: "repo",
-      filePath: "",
-      languages: ["typescript", "python"],
-      frameworks: ["react", "fastapi"],
-      iacTypes: ["terraform"],
-      apiContracts: ["openapi"],
-      manifests: ["package.json", "pyproject.toml"],
-      srcDirs: ["src", "packages"],
-    } as unknown as GraphNode);
-
-    await store.bulkLoad(g);
-
-    const fRow = await store.query(
-      `SELECT severity, rule_id, scanner_id, message, properties_bag
-       FROM nodes WHERE id = ?`,
-      [findingId],
-    );
-    const fr = fRow[0];
-    assert.ok(fr);
-    assert.equal(fr["severity"], "warning");
-    assert.equal(fr["rule_id"], "rule-x");
-    assert.equal(fr["scanner_id"], "semgrep");
-    assert.equal(fr["message"], "Possible XSS sink");
-    const bag = JSON.parse(String(fr["properties_bag"])) as Record<string, unknown>;
-    assert.equal(bag["cwe"], "CWE-79");
-    assert.equal(bag["confidence"], "HIGH");
-
-    const dRow = await store.query(
-      "SELECT version, license, lockfile_source, ecosystem FROM nodes WHERE id = ?",
-      [depId],
-    );
-    const dr = dRow[0];
-    assert.ok(dr);
-    assert.equal(dr["version"], "18.2.0");
-    assert.equal(dr["license"], "MIT");
-    assert.equal(dr["lockfile_source"], "package-lock.json");
-    assert.equal(dr["ecosystem"], "npm");
-
-    const oRow = await store.query(
-      "SELECT http_method, http_path, summary, operation_id, method FROM nodes WHERE id = ?",
-      [opId],
-    );
-    const or = oRow[0];
-    assert.ok(or);
-    assert.equal(or["http_method"], "GET");
-    assert.equal(or["http_path"], "/users/{id}");
-    assert.equal(or["summary"], "Fetch one user by id");
-    assert.equal(or["operation_id"], "getUserById");
-    // OperationNode.method must NOT leak into the route-scoped `method` column.
-    assert.equal(or["method"], null);
-
-    const cRow = await store.query("SELECT email_hash, email_plain FROM nodes WHERE id = ?", [
-      contribId,
-    ]);
-    const cr = cRow[0];
-    assert.ok(cr);
-    assert.equal(cr["email_hash"], "7a0fcafedeadbeef");
-    assert.equal(cr["email_plain"], "alice@example.com");
-
-    const pRow = await store.query(
-      `SELECT languages_json, frameworks_json, iac_types_json,
-              api_contracts_json, manifests_json, src_dirs_json
-       FROM nodes WHERE id = ?`,
-      [profileId],
-    );
-    const pr = pRow[0];
-    assert.ok(pr);
-    assert.deepEqual(JSON.parse(String(pr["languages_json"])), ["typescript", "python"]);
-    assert.deepEqual(JSON.parse(String(pr["frameworks_json"])), ["react", "fastapi"]);
-    assert.deepEqual(JSON.parse(String(pr["iac_types_json"])), ["terraform"]);
-    assert.deepEqual(JSON.parse(String(pr["api_contracts_json"])), ["openapi"]);
-    assert.deepEqual(JSON.parse(String(pr["manifests_json"])), ["package.json", "pyproject.toml"]);
-    assert.deepEqual(JSON.parse(String(pr["src_dirs_json"])), ["src", "packages"]);
-  } finally {
-    await store.close();
-  }
-});
-
-test("bulkLoad stores Repo columns (first-class repo node)", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    const g = new KnowledgeGraph();
-    const repoId = makeNodeId("Repo", "", "repo");
-    g.addNode({
-      id: repoId,
-      kind: "Repo",
-      name: "github.com/acme/example",
-      filePath: "",
-      originUrl: "https://github.com/acme/example.git",
-      repoUri: "github.com/acme/example",
-      defaultBranch: "main",
-      commitSha: "0123456789abcdef0123456789abcdef01234567",
-      indexTime: "2026-05-06T12:34:56Z",
-      group: "acme",
-      visibility: "internal",
-      indexer: "opencodehub@0.1.0",
-      languageStats: { ts: 0.83, py: 0.14, md: 0.03 },
-    } as unknown as GraphNode);
-    await store.bulkLoad(g);
-
-    const rRow = await store.query(
-      `SELECT origin_url, repo_uri, default_branch, commit_sha, index_time,
-              repo_group, visibility, indexer, language_stats_json
-       FROM nodes WHERE id = ?`,
-      [repoId],
-    );
-    const rr = rRow[0];
-    assert.ok(rr);
-    assert.equal(rr["origin_url"], "https://github.com/acme/example.git");
-    assert.equal(rr["repo_uri"], "github.com/acme/example");
-    assert.equal(rr["default_branch"], "main");
-    assert.equal(rr["commit_sha"], "0123456789abcdef0123456789abcdef01234567");
-    assert.equal(rr["index_time"], "2026-05-06T12:34:56Z");
-    assert.equal(rr["repo_group"], "acme");
-    assert.equal(rr["visibility"], "internal");
-    assert.equal(rr["indexer"], "opencodehub@0.1.0");
-    // canonicalJson sorts keys — the stored JSON must match the sorted form.
-    assert.equal(rr["language_stats_json"], '{"md":0.03,"py":0.14,"ts":0.83}');
-  } finally {
-    await store.close();
-  }
-});
-
-test("bulkLoad stores Repo columns with explicit-null nullable fields", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    const g = new KnowledgeGraph();
-    const repoId = makeNodeId("Repo", "", "repo");
-    g.addNode({
-      id: repoId,
-      kind: "Repo",
-      name: "local:abcdef012345",
-      filePath: "",
-      originUrl: null,
-      repoUri: "local:abcdef012345",
-      defaultBranch: null,
-      commitSha: "0123456789abcdef0123456789abcdef01234567",
-      indexTime: "2026-05-06T12:34:56Z",
-      group: null,
-      visibility: "private",
-      indexer: "opencodehub@0.1.0",
-      languageStats: {},
-    } as unknown as GraphNode);
-    await store.bulkLoad(g);
-
-    const rRow = await store.query(
-      `SELECT origin_url, default_branch, repo_group, language_stats_json
-       FROM nodes WHERE id = ?`,
-      [repoId],
-    );
-    const rr = rRow[0];
-    assert.ok(rr);
-    // Nullable interface fields ({origin_url, default_branch, repo_group})
-    // round-trip to SQL NULL when the source node carries `null`.
-    assert.equal(rr["origin_url"], null);
-    assert.equal(rr["default_branch"], null);
-    assert.equal(rr["repo_group"], null);
-    // Empty languageStats collapses to NULL on the wire — the read path
-    // reconstructs `{}` so graph-hash parity holds.
-    assert.equal(rr["language_stats_json"], null);
-  } finally {
-    await store.close();
-  }
-});
-
-test("bulkLoad stores FOUND_IN / DEPENDS_ON / OWNED_BY relation types", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    const g = new KnowledgeGraph();
-
-    const fileA = makeNodeId("File", "src/a.ts", "a.ts");
-    const fnA = makeNodeId("Function", "src/a.ts", "alpha");
-    const findingX = makeNodeId("Finding", "src/a.ts", "X#1");
-    const depY = makeNodeId("Dependency", "package-lock.json", "react@18.2.0");
-    const contribZ = makeNodeId("Contributor", "", "hashZ");
-
-    g.addNode({ id: fileA, kind: "File", name: "a.ts", filePath: "src/a.ts" });
-    g.addNode({ id: fnA, kind: "Function", name: "alpha", filePath: "src/a.ts" });
-    g.addNode({
-      id: findingX,
-      kind: "Finding",
-      name: "X#1",
-      filePath: "src/a.ts",
-      ruleId: "X",
-      severity: "error",
-      scannerId: "s",
-      message: "bad",
-      propertiesBag: {},
-    } as unknown as GraphNode);
-    g.addNode({
-      id: depY,
-      kind: "Dependency",
-      name: "react",
-      filePath: "package-lock.json",
-      version: "18.2.0",
-      ecosystem: "npm",
-      lockfileSource: "package-lock.json",
-    } as unknown as GraphNode);
-    g.addNode({
-      id: contribZ,
-      kind: "Contributor",
-      name: "Z",
-      filePath: "",
-      emailHash: "hashZ",
-    } as unknown as GraphNode);
-
-    g.addEdge({ from: findingX, to: fileA, type: "FOUND_IN", confidence: 1.0 });
-    g.addEdge({ from: fileA, to: depY, type: "DEPENDS_ON", confidence: 0.9 });
-    g.addEdge({ from: fnA, to: contribZ, type: "OWNED_BY", confidence: 0.8 });
-
-    await store.bulkLoad(g);
-
-    const rows = await store.query(
-      "SELECT type, COUNT(*) AS n FROM relations GROUP BY type ORDER BY type",
-    );
-    const byType = new Map<string, number>();
-    for (const r of rows) byType.set(String(r["type"]), Number(r["n"]));
-    assert.equal(byType.get("FOUND_IN"), 1);
-    assert.equal(byType.get("DEPENDS_ON"), 1);
-    assert.equal(byType.get("OWNED_BY"), 1);
-    // COCHANGES must never appear in `relations` after the table split.
-    assert.equal(byType.get("COCHANGES"), undefined);
-
-    // Traversal must default-include the new types when no filter is passed.
-    const down = await store.traverse({
-      startId: findingX,
-      direction: "down",
-      maxDepth: 1,
-    });
-    assert.ok(
-      down.some((r) => r.nodeId === fileA),
-      "FOUND_IN edge must be reachable via default traverse()",
-    );
-  } finally {
-    await store.close();
-  }
-});
-
 test("bulkLoadCochanges: replaces rows and sorts insertion deterministically", async () => {
   const dbPath = await scratchDbPath();
   const store = new DuckDbStore(dbPath);
@@ -1131,7 +42,7 @@ test("bulkLoadCochanges: replaces rows and sorts insertion deterministically", a
       },
     ]);
 
-    const rows = await store.query(
+    const rows = await store.exec(
       "SELECT source_file, target_file, cocommit_count, lift FROM cochanges ORDER BY source_file, target_file",
     );
     assert.equal(rows.length, 2);
@@ -1150,7 +61,7 @@ test("bulkLoadCochanges: replaces rows and sorts insertion deterministically", a
         lift: 5.0,
       },
     ]);
-    const after = await store.query("SELECT source_file FROM cochanges");
+    const after = await store.exec("SELECT source_file FROM cochanges");
     assert.equal(after.length, 1);
     assert.equal(after[0]?.["source_file"], "src/x.ts");
   } finally {
@@ -1388,775 +299,39 @@ test("lookupSymbolSummariesByNode: returns rows for every requested node, ordere
 });
 
 // ---------------------------------------------------------------------------
-// UPSERT mode ( incremental indexing)
-// ---------------------------------------------------------------------------
-
-test("bulkLoad(mode=upsert): second batch overwrites overlap, preserves non-overlap", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-
-    // Batch A: 4 functions in two files.
-    const batchA = new KnowledgeGraph();
-    const idA = makeNodeId("Function", "src/x.ts", "fnA");
-    const idB = makeNodeId("Function", "src/x.ts", "fnB");
-    const idC = makeNodeId("Function", "src/y.ts", "fnC");
-    const idD = makeNodeId("Function", "src/y.ts", "fnD");
-    batchA.addNode({
-      id: idA,
-      kind: "Function",
-      name: "fnA",
-      filePath: "src/x.ts",
-      signature: "v1_A",
-    });
-    batchA.addNode({
-      id: idB,
-      kind: "Function",
-      name: "fnB",
-      filePath: "src/x.ts",
-      signature: "v1_B",
-    });
-    batchA.addNode({
-      id: idC,
-      kind: "Function",
-      name: "fnC",
-      filePath: "src/y.ts",
-      signature: "v1_C",
-    });
-    batchA.addNode({
-      id: idD,
-      kind: "Function",
-      name: "fnD",
-      filePath: "src/y.ts",
-      signature: "v1_D",
-    });
-    await store.bulkLoad(batchA, { mode: "replace" });
-
-    // Batch B: 50% overlap (fnB, fnC updated) + 50% new (fnE, fnF). UPSERT
-    // must keep fnA + fnD intact and replace signature for fnB + fnC.
-    const batchB = new KnowledgeGraph();
-    batchB.addNode({
-      id: idB,
-      kind: "Function",
-      name: "fnB",
-      filePath: "src/x.ts",
-      signature: "v2_B",
-    });
-    batchB.addNode({
-      id: idC,
-      kind: "Function",
-      name: "fnC",
-      filePath: "src/y.ts",
-      signature: "v2_C",
-    });
-    const idE = makeNodeId("Function", "src/z.ts", "fnE");
-    const idF = makeNodeId("Function", "src/z.ts", "fnF");
-    batchB.addNode({
-      id: idE,
-      kind: "Function",
-      name: "fnE",
-      filePath: "src/z.ts",
-      signature: "v2_E",
-    });
-    batchB.addNode({
-      id: idF,
-      kind: "Function",
-      name: "fnF",
-      filePath: "src/z.ts",
-      signature: "v2_F",
-    });
-    await store.bulkLoad(batchB, { mode: "upsert" });
-
-    const total = await store.query("SELECT COUNT(*) AS n FROM nodes");
-    assert.equal(Number(total[0]?.["n"]), 6, "A-only + overlap-updated + B-only = 6 rows");
-
-    const rows = await store.query(
-      "SELECT id, signature FROM nodes WHERE kind = 'Function' ORDER BY id",
-    );
-    const sigById = new Map<string, string>();
-    for (const r of rows) sigById.set(String(r["id"]), String(r["signature"]));
-    assert.equal(sigById.get(idA), "v1_A", "non-overlap A-side row must be preserved");
-    assert.equal(sigById.get(idD), "v1_D", "non-overlap A-side row must be preserved");
-    assert.equal(sigById.get(idB), "v2_B", "overlap row must be updated to batch-B value");
-    assert.equal(sigById.get(idC), "v2_C", "overlap row must be updated to batch-B value");
-    assert.equal(sigById.get(idE), "v2_E", "new B-only row must be inserted");
-    assert.equal(sigById.get(idF), "v2_F", "new B-only row must be inserted");
-  } finally {
-    await store.close();
-  }
-});
-
-test("bulkLoad(mode=upsert): issue 8147 guard — duplicate ids in one batch keep last value", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-
-    // KnowledgeGraph's addNode uses definedFieldCount for its own dedupe, so
-    // to smuggle a true duplicate through to the adapter we build an ordered
-    // node list manually with different field counts — the LAST occurrence
-    // (with more fields) must win, matching the adapter's dedupeLastById.
-    const graph = new KnowledgeGraph();
-    const id = makeNodeId("Function", "src/dup.ts", "fnDup");
-    // First addNode: signature v1 (stored because no existing node).
-    graph.addNode({
-      id,
-      kind: "Function",
-      name: "fnDup",
-      filePath: "src/dup.ts",
-      signature: "v1",
-    });
-    // Second addNode: richer field set → replaces the previous in the map.
-    graph.addNode({
-      id,
-      kind: "Function",
-      name: "fnDup",
-      filePath: "src/dup.ts",
-      signature: "v2",
-      parameterCount: 3,
-      isExported: true,
-    });
-
-    await store.bulkLoad(graph, { mode: "upsert" });
-    const rows = await store.query("SELECT signature, parameter_count FROM nodes WHERE id = ?", [
-      id,
-    ]);
-    assert.equal(rows.length, 1, "single row for duplicate id");
-    assert.equal(rows[0]?.["signature"], "v2", "last occurrence wins on dedupe");
-    assert.equal(Number(rows[0]?.["parameter_count"]), 3);
-  } finally {
-    await store.close();
-  }
-});
-
-test("bulkLoad(mode=upsert): propertiesBag round-trips as JSON and languages as array", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    const g = new KnowledgeGraph();
-    const findingId = makeNodeId("Finding", "src/a.ts", "rule-a#1");
-    const bag = { cwe: "CWE-79", nested: { score: 7.4 }, tags: ["xss", "http"] };
-    g.addNode({
-      id: findingId,
-      kind: "Finding",
-      name: "rule-a#1",
-      filePath: "src/a.ts",
-      ruleId: "rule-a",
-      severity: "error",
-      scannerId: "semgrep",
-      message: "hi",
-      propertiesBag: bag,
-    } as unknown as GraphNode);
-
-    const profileId = makeNodeId("ProjectProfile", "", "repo");
-    g.addNode({
-      id: profileId,
-      kind: "ProjectProfile",
-      name: "repo",
-      filePath: "",
-      languages: ["typescript", "python", "go"],
-      frameworks: [],
-      iacTypes: [],
-      apiContracts: [],
-      manifests: [],
-      srcDirs: [],
-    } as unknown as GraphNode);
-
-    await store.bulkLoad(g, { mode: "upsert" });
-
-    const frow = await store.query("SELECT properties_bag FROM nodes WHERE id = ?", [findingId]);
-    assert.deepEqual(JSON.parse(String(frow[0]?.["properties_bag"])), bag);
-
-    const prow = await store.query("SELECT languages_json FROM nodes WHERE id = ?", [profileId]);
-    assert.deepEqual(JSON.parse(String(prow[0]?.["languages_json"])), [
-      "typescript",
-      "python",
-      "go",
-    ]);
-  } finally {
-    await store.close();
-  }
-});
-
-test("setMeta / getMeta round-trips cacheHitRatio / cacheSizeBytes / lastCompaction", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    const meta: StoreMeta = {
-      schemaVersion: "1.1.0",
-      lastCommit: "cafebabe",
-      indexedAt: "2026-04-18T11:00:00Z",
-      nodeCount: 10,
-      edgeCount: 20,
-      cacheHitRatio: 0.73,
-      cacheSizeBytes: 1048576,
-      lastCompaction: "2026-04-18T09:30:00Z",
-    };
-    await store.setMeta(meta);
-    const readBack = await store.getMeta();
-    assert.deepEqual(readBack, meta);
-  } finally {
-    await store.close();
-  }
-});
-
-// ---------------------------------------------------------------------------
-// v1.2 reserved columns (P08)
+// exec + healthCheck
 // ---------------------------------------------------------------------------
 
-test("v1.2: reserved columns round-trip through nodes table", async () => {
+test("exec + healthCheck round-trip on a fresh schema", async () => {
   const dbPath = await scratchDbPath();
   const store = new DuckDbStore(dbPath);
   await store.open();
   try {
     await store.createSchema();
-    const g = new KnowledgeGraph();
-    const funcId = makeNodeId("Function", "src/a.ts", "complex");
-    // Callable carrying every v1.2 reserved column.
-    g.addNode({
-      id: funcId,
-      kind: "Function",
-      name: "complex",
-      filePath: "src/a.ts",
-      startLine: 1,
-      endLine: 20,
-      cyclomaticComplexity: 7,
-      nestingDepth: 3,
-      nloc: 15,
-      halsteadVolume: 42.5,
-      deadness: "live",
-      coveragePercent: 0.83,
-      coveredLinesJson: JSON.stringify([1, 2, 3, 5, 8, 13]),
-    });
-    const toolId = makeNodeId("Tool", "tools/echo.ts", "echo");
-    g.addNode({
-      id: toolId,
-      kind: "Tool",
-      name: "echo",
-      filePath: "tools/echo.ts",
-      toolName: "echo",
-      inputSchemaJson: '{"properties":{"s":{"type":"string"}},"type":"object"}',
-    });
-    const findingId = makeNodeId("Finding", "src/a.ts", "semgrep:rule:5");
-    g.addNode({
-      id: findingId,
-      kind: "Finding",
-      name: "semgrep:rule",
-      filePath: "src/a.ts",
-      ruleId: "rule",
-      severity: "error",
-      scannerId: "semgrep",
-      message: "boom",
-      propertiesBag: {},
-      startLine: 5,
-      partialFingerprint: "ab".repeat(16),
-      baselineState: "new",
-      suppressedJson: '[{"kind":"external","justification":"accepted"}]',
-    });
-    await store.bulkLoad(g);
-
-    const rows = await store.query(
-      `SELECT id, cyclomatic_complexity, nesting_depth, nloc, halstead_volume,
-              deadness, coverage_percent, covered_lines_json,
-              input_schema_json, partial_fingerprint, baseline_state,
-              suppressed_json
-       FROM nodes
-       WHERE id = ? OR id = ? OR id = ?
-       ORDER BY id`,
-      [findingId, funcId, toolId],
-    );
-    assert.equal(rows.length, 3);
-    const byId = new Map(rows.map((r) => [String(r["id"]), r]));
-    const funcRow = byId.get(funcId);
-    const toolRow = byId.get(toolId);
-    const findingRow = byId.get(findingId);
-    assert.ok(funcRow && toolRow && findingRow);
-    assert.equal(Number(funcRow["cyclomatic_complexity"]), 7);
-    assert.equal(Number(funcRow["nesting_depth"]), 3);
-    assert.equal(Number(funcRow["nloc"]), 15);
-    assert.equal(Number(funcRow["halstead_volume"]), 42.5);
-    assert.equal(funcRow["deadness"], "live");
-    assert.equal(Number(funcRow["coverage_percent"]), 0.83);
-    assert.equal(funcRow["covered_lines_json"], JSON.stringify([1, 2, 3, 5, 8, 13]));
-    assert.equal(
-      toolRow["input_schema_json"],
-      '{"properties":{"s":{"type":"string"}},"type":"object"}',
-    );
-    assert.equal(findingRow["partial_fingerprint"], "ab".repeat(16));
-    assert.equal(findingRow["baseline_state"], "new");
-    assert.equal(findingRow["suppressed_json"], '[{"kind":"external","justification":"accepted"}]');
-  } finally {
-    await store.close();
-  }
-});
-
-test("v1.2: nodes without reserved fields round-trip to NULL (v1.0-style graph)", async () => {
-  const dbPath = await scratchDbPath();
-  const writer = new DuckDbStore(dbPath);
-  await writer.open();
-  try {
-    await writer.createSchema();
-    const g = new KnowledgeGraph();
-    const funcId = makeNodeId("Function", "src/a.ts", "plain");
-    g.addNode({
-      id: funcId,
-      kind: "Function",
-      name: "plain",
-      filePath: "src/a.ts",
-      startLine: 1,
-      endLine: 3,
-    });
-    await writer.bulkLoad(g);
-  } finally {
-    await writer.close();
-  }
+    const h = await store.healthCheck();
+    assert.equal(h.ok, true);
 
-  // Reopen with a fresh adapter (mimics "v1.0 graph opened by v1.2 reader").
-  const reader = new DuckDbStore(dbPath, { readOnly: true });
-  await reader.open();
-  try {
-    const rows = await reader.query(
-      `SELECT cyclomatic_complexity, nesting_depth, nloc, halstead_volume,
-              deadness, coverage_percent, covered_lines_json,
-              input_schema_json, partial_fingerprint, baseline_state,
-              suppressed_json
-       FROM nodes WHERE kind = 'Function'`,
+    // The temporal schema exposes cochanges + symbol_summaries — any other
+    // graph-tier table must not exist.
+    const cochangeCount = await store.exec("SELECT COUNT(*) AS n FROM cochanges");
+    const summaryCount = await store.exec("SELECT COUNT(*) AS n FROM symbol_summaries");
+    assert.equal(Number(cochangeCount[0]?.["n"]), 0);
+    assert.equal(Number(summaryCount[0]?.["n"]), 0);
+
+    // Graph-tier tables (nodes / relations / embeddings) must NOT exist.
+    await assert.rejects(
+      () => store.exec("SELECT COUNT(*) FROM nodes"),
+      /nodes/,
+      "temporal.duckdb must not carry the nodes table",
     );
-    assert.equal(rows.length, 1);
-    const r = rows[0];
-    assert.ok(r);
-    for (const col of [
-      "cyclomatic_complexity",
-      "nesting_depth",
-      "nloc",
-      "halstead_volume",
-      "deadness",
-      "coverage_percent",
-      "covered_lines_json",
-      "input_schema_json",
-      "partial_fingerprint",
-      "baseline_state",
-      "suppressed_json",
-    ]) {
-      assert.equal(r[col], null, `column ${col} must be NULL on a plain node`);
-    }
-  } finally {
-    await reader.close();
-  }
-});
-
-test("v1.2: dead-code hyphen verdict maps to underscored column value", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    const g = new KnowledgeGraph();
-    const funcId = makeNodeId("Function", "src/a.ts", "exported");
-    // The analysis helper emits "unreachable-export" (hyphen); the column
-    // schema and core-types enum use "unreachable_export" (underscore). The
-    // adapter's normaliser must bridge the two forms.
-    g.addNode({
-      id: funcId,
-      kind: "Function",
-      name: "exported",
-      filePath: "src/a.ts",
-      startLine: 1,
-      endLine: 3,
-      // Cast through unknown because the in-memory graph tolerates the
-      // hyphen form, but the persistent enum uses underscore.
-      ...({ deadness: "unreachable-export" } as unknown as { deadness: "unreachable_export" }),
-    });
-    await store.bulkLoad(g);
-    const rows = await store.query("SELECT deadness FROM nodes WHERE id = ?", [funcId]);
-    assert.equal(rows[0]?.["deadness"], "unreachable_export");
-  } finally {
-    await store.close();
-  }
-});
-
-test("v1.2: graphHash stays deterministic when reserved fields are populated", async () => {
-  const g1 = new KnowledgeGraph();
-  const g2 = new KnowledgeGraph();
-  const funcId = makeNodeId("Function", "src/a.ts", "graphHashed");
-  // Build two graphs with the SAME set of fields but declared in different
-  // literal orders — canonical JSON must re-sort keys so both hashes agree.
-  g1.addNode({
-    id: funcId,
-    kind: "Function",
-    name: "graphHashed",
-    filePath: "src/a.ts",
-    startLine: 1,
-    endLine: 10,
-    cyclomaticComplexity: 4,
-    halsteadVolume: 17.25,
-    nestingDepth: 2,
-    nloc: 8,
-    deadness: "live",
-    coveragePercent: 0.5,
-    coveredLinesJson: JSON.stringify([1, 2]),
-  });
-  g2.addNode({
-    id: funcId,
-    kind: "Function",
-    name: "graphHashed",
-    filePath: "src/a.ts",
-    startLine: 1,
-    endLine: 10,
-    // Different insertion order, same values.
-    coveredLinesJson: JSON.stringify([1, 2]),
-    coveragePercent: 0.5,
-    deadness: "live",
-    nloc: 8,
-    nestingDepth: 2,
-    halsteadVolume: 17.25,
-    cyclomaticComplexity: 4,
-  });
-  assert.equal(graphHash(g1), graphHash(g2));
-
-  // Re-hashing the same graph twice must produce a stable hex string.
-  const h1 = graphHash(g1);
-  const h2 = graphHash(g1);
-  assert.equal(h1, h2);
-  assert.ok(/^[0-9a-f]{64}$/.test(h1), "graphHash must be a 64-char hex sha256");
-});
-
-// ---------------------------------------------------------------------------
-// listNodes — kind filter, determinism, limit/offset
-// ---------------------------------------------------------------------------
-
-/**
- * Build a heterogenous graph that exercises every column family `listNodes`
- * is expected to round-trip: File / Function / Class / Method (the basic
- * shapes), plus Dependency (the wider columns lesson — `version`,
- * `license`, `lockfile_source`, `ecosystem`), Operation (column aliasing
- * `http_method`/`http_path` ↔ `method`/`path`), and Repo (M6 nullable
- * fields + canonical-JSON `languageStats`).
- *
- * Reused by the cross-adapter parity test below.
- */
-function buildListNodesFixture(): KnowledgeGraph {
-  const g = new KnowledgeGraph();
-  const fileA = makeNodeId("File", "src/a.ts", "a.ts");
-  const fileB = makeNodeId("File", "src/b.ts", "b.ts");
-  g.addNode({ id: fileA, kind: "File", name: "a.ts", filePath: "src/a.ts" });
-  g.addNode({ id: fileB, kind: "File", name: "b.ts", filePath: "src/b.ts" });
-
-  for (let i = 0; i < 3; i += 1) {
-    const id = makeNodeId("Function", "src/a.ts", `fn_${i}`, { parameterCount: i });
-    g.addNode({
-      id,
-      kind: "Function",
-      name: `fn_${i}`,
-      filePath: "src/a.ts",
-      startLine: 10 + i,
-      endLine: 20 + i,
-      signature: `function fn_${i}()`,
-      parameterCount: i,
-      isExported: i === 0,
-    });
-  }
-
-  const cls = makeNodeId("Class", "src/b.ts", "Service");
-  g.addNode({
-    id: cls,
-    kind: "Class",
-    name: "Service",
-    filePath: "src/b.ts",
-    isExported: true,
-    startLine: 1,
-    endLine: 30,
-  });
-  g.addNode({
-    id: makeNodeId("Method", "src/b.ts", "Service.greet"),
-    kind: "Method",
-    name: "greet",
-    filePath: "src/b.ts",
-    startLine: 5,
-    endLine: 9,
-    parameterCount: 1,
-  });
-
-  // Dependency rows exercise the wider polymorphic columns. Two ecosystems
-  // so the kind-filter test sees more than one row per kind.
-  g.addNode({
-    id: makeNodeId("Dependency", "package.json", "lodash@4.17.21"),
-    kind: "Dependency",
-    name: "lodash",
-    filePath: "package.json",
-    version: "4.17.21",
-    ecosystem: "npm",
-    lockfileSource: "pnpm-lock.yaml",
-    license: "MIT",
-  });
-  g.addNode({
-    id: makeNodeId("Dependency", "requirements.txt", "requests@2.31.0"),
-    kind: "Dependency",
-    name: "requests",
-    filePath: "requirements.txt",
-    version: "2.31.0",
-    ecosystem: "pypi",
-    lockfileSource: "requirements.txt",
-  });
-
-  // Operation kind exercises the http_method/http_path → method/path column
-  // aliasing.
-  g.addNode({
-    id: makeNodeId("Operation", "openapi.yaml", "GET /v1/users"),
-    kind: "Operation",
-    name: "listUsers",
-    filePath: "openapi.yaml",
-    method: "GET",
-    path: "/v1/users",
-    operationId: "listUsers",
-  });
-
-  // Repo kind exercises the M6 nullable fields + canonical-JSON languageStats.
-  g.addNode({
-    id: makeNodeId("Repo", "", "repo"),
-    kind: "Repo",
-    name: "test-repo",
-    filePath: ".",
-    originUrl: "https://github.com/example/test-repo",
-    repoUri: "github.com/example/test-repo",
-    defaultBranch: "main",
-    commitSha: "0123456789abcdef0123456789abcdef01234567",
-    indexTime: "2026-05-07T00:00:00Z",
-    group: null,
-    visibility: "public",
-    indexer: "och-test/0.1.0",
-    languageStats: { ts: 0.7, py: 0.3 },
-  });
-
-  return g;
-}
-
-test("listNodes() returns every kind when no filter is supplied", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    const g = buildListNodesFixture();
-    await store.bulkLoad(g);
-
-    const all = await store.listNodes();
-    assert.equal(all.length, g.nodeCount());
-
-    // Spot-check the kind distribution: 2 Files, 3 Functions, 1 Class, 1
-    // Method, 2 Dependencies, 1 Operation, 1 Repo.
-    const byKind = new Map<string, number>();
-    for (const n of all) byKind.set(n.kind, (byKind.get(n.kind) ?? 0) + 1);
-    assert.equal(byKind.get("File"), 2);
-    assert.equal(byKind.get("Function"), 3);
-    assert.equal(byKind.get("Class"), 1);
-    assert.equal(byKind.get("Method"), 1);
-    assert.equal(byKind.get("Dependency"), 2);
-    assert.equal(byKind.get("Operation"), 1);
-    assert.equal(byKind.get("Repo"), 1);
-  } finally {
-    await store.close();
-  }
-});
-
-test("listNodes() filters by kind and returns wider columns for Dependency rows", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    await store.bulkLoad(buildListNodesFixture());
-
-    const deps = await store.listNodes({ kinds: ["Dependency"] });
-    assert.equal(deps.length, 2);
-    for (const dep of deps) {
-      assert.equal(dep.kind, "Dependency");
-      // Wider columns must round-trip — the whole reason listNodes exists
-      // (vs `query("SELECT id, name FROM nodes WHERE kind = ?")`).
-      const d = dep as GraphNode & {
-        version: string;
-        ecosystem: string;
-        lockfileSource: string;
-      };
-      assert.equal(typeof d.version, "string");
-      assert.equal(typeof d.ecosystem, "string");
-      assert.equal(typeof d.lockfileSource, "string");
-    }
-    const lodash = deps.find((d) => d.name === "lodash");
-    assert.ok(lodash);
-    assert.equal((lodash as GraphNode & { license: string }).license, "MIT");
-  } finally {
-    await store.close();
-  }
-});
-
-test("listNodes() with multiple kinds OR-filters", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    await store.bulkLoad(buildListNodesFixture());
-
-    const both = await store.listNodes({ kinds: ["Function", "Class"] });
-    const kindSet = new Set(both.map((n) => n.kind));
-    assert.deepEqual([...kindSet].sort(), ["Class", "Function"]);
-    assert.equal(both.length, 4); // 3 Functions + 1 Class
-  } finally {
-    await store.close();
-  }
-});
-
-test("listNodes() with an empty kinds array returns no rows", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    await store.bulkLoad(buildListNodesFixture());
-
-    const empty = await store.listNodes({ kinds: [] });
-    assert.deepEqual(empty, []);
-  } finally {
-    await store.close();
-  }
-});
-
-test("listNodes() ORDER BY id ASC is deterministic across two writes", async () => {
-  const g = buildListNodesFixture();
-  // Same fixture, two independent stores. The IDs are content-derived so
-  // both runs produce identical ID strings — listNodes must therefore yield
-  // the exact same ordered list of ids.
-  const pathA = await scratchDbPath();
-  const storeA = new DuckDbStore(pathA);
-  await storeA.open();
-  await storeA.createSchema();
-  await storeA.bulkLoad(g);
-  const idsA = (await storeA.listNodes()).map((n) => n.id);
-  await storeA.close();
-
-  const pathB = await scratchDbPath();
-  const storeB = new DuckDbStore(pathB);
-  await storeB.open();
-  await storeB.createSchema();
-  await storeB.bulkLoad(g);
-  const idsB = (await storeB.listNodes()).map((n) => n.id);
-  await storeB.close();
-
-  assert.deepEqual(idsA, idsB);
-  // Verify the order is actually sorted (sanity: not just "same junk ordering twice").
-  const sorted = [...idsA].sort();
-  assert.deepEqual(idsA, sorted);
-});
 
-test("listNodes() applies limit + offset against the sorted result", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    await store.bulkLoad(buildListNodesFixture());
-
-    const all = await store.listNodes();
-    const total = all.length;
-    assert.ok(total >= 4, "fixture should have at least 4 nodes for paging");
-
-    const firstPage = await store.listNodes({ limit: 2 });
-    const secondPage = await store.listNodes({ limit: 2, offset: 2 });
-    assert.equal(firstPage.length, 2);
-    assert.equal(secondPage.length, 2);
-    assert.deepEqual(
-      firstPage.map((n) => n.id),
-      all.slice(0, 2).map((n) => n.id),
+    // exec rejects writes via the SQL guard.
+    await assert.rejects(
+      () => store.exec("CREATE TABLE x (a INT)"),
+      /CREATE/,
+      "exec must reject writes",
     );
-    assert.deepEqual(
-      secondPage.map((n) => n.id),
-      all.slice(2, 4).map((n) => n.id),
-    );
-  } finally {
-    await store.close();
-  }
-});
-
-test("listNodes() rehydrates Operation http_method / http_path back to method / path", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    await store.bulkLoad(buildListNodesFixture());
-
-    const ops = await store.listNodes({ kinds: ["Operation"] });
-    assert.equal(ops.length, 1);
-    const op = ops[0] as GraphNode & { method: string; path: string };
-    assert.equal(op.method, "GET");
-    assert.equal(op.path, "/v1/users");
-  } finally {
-    await store.close();
-  }
-});
-
-test("listNodes() preserves Repo nullable fields and languageStats", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    await store.bulkLoad(buildListNodesFixture());
-
-    const repos = await store.listNodes({ kinds: ["Repo"] });
-    assert.equal(repos.length, 1);
-    const repo = repos[0] as GraphNode & {
-      originUrl: string | null;
-      defaultBranch: string | null;
-      group: string | null;
-      languageStats: Readonly<Record<string, number>>;
-    };
-    assert.equal(repo.originUrl, "https://github.com/example/test-repo");
-    assert.equal(repo.defaultBranch, "main");
-    // The fixture sets `group: null`; that must round-trip explicitly.
-    assert.equal(repo.group, null);
-    assert.deepEqual(repo.languageStats, { ts: 0.7, py: 0.3 });
   } finally {
     await store.close();
   }
 });
-
-test("listNodes() returns [] from an unknown kind", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  try {
-    await store.createSchema();
-    await store.bulkLoad(buildListNodesFixture());
-
-    const none = await store.listNodes({ kinds: ["DoesNotExist"] });
-    assert.deepEqual(none, []);
-  } finally {
-    await store.close();
-  }
-});
-
-// ---------------------------------------------------------------------------
-// v1.0 community-adapter conformance suite
-//
-// DuckDb is the flagship reference implementation, so it MUST pass every
-// block of the shared conformance contract. A regression here would mean
-// the in-tree adapter has diverged from the published v1.0 contract and
-// every community fork would be at risk.
-// ---------------------------------------------------------------------------
-
-assertIGraphStoreConformance("DuckDb", async () => {
-  const dbPath = await scratchDbPath();
-  const store = new DuckDbStore(dbPath);
-  await store.open();
-  await store.createSchema();
-  return store;
-});
diff --git a/packages/storage/src/duckdb-adapter.ts b/packages/storage/src/duckdb-adapter.ts
index 8378d2c8..522c0361 100644
--- a/packages/storage/src/duckdb-adapter.ts
+++ b/packages/storage/src/duckdb-adapter.ts
@@ -1,169 +1,68 @@
 /**
- * DuckDB-backed adapter for the storage interfaces.
+ * DuckDB-backed adapter for the temporal storage interface.
  *
- * This class implements BOTH {@link IGraphStore} and {@link ITemporalStore}
- * over a single `DuckDBConnection`. The legacy `DuckDbStore` class export
- * is retained as the bridge type for the type-pin call sites that still
- * consume the merged surface — its instances satisfy the union of both
- * surfaces.
+ * This class implements {@link ITemporalStore} only. The graph tier is
+ * served by `GraphDbStore` (`@ladybugdb/core`); the temporal tier owns
+ * cochange statistics, structured symbol summaries, and the
+ * `codehub query --sql` escape hatch.
  *
- * When a caller composes a {@link OpenStoreResult} with `backend: "duck"`,
- * the same `DuckDbStore` instance is returned as both the `graph` view
- * and the `temporal` view (no second file). When `backend: "lbug"`,
- * `GraphDbStore` provides the graph view and a separate `DuckDbStore`
- * instance over `<path>.temporal.duckdb` provides the temporal view.
+ * Lifecycle: `open` → `createSchema` → `bulkLoadCochanges` /
+ * `bulkLoadSymbolSummaries` → `lookupCochangesForFile` /
+ * `lookupSymbolSummary` / `exec` → `close`.
  *
- * Lifecycle: `open` → `createSchema` → `bulkLoad` (once per index run) →
- * `query` / `exec` / `search` / `vectorSearch` / `traverse` against the
- * same connection → `close`.
- *
- * Extensions:
- *   - `hnsw_acorn` (community extension) — registers an `HNSW` index type
- *     that respects WHERE clauses via ACORN-1. If the install fails at open
- *     time (e.g. no network on first use, or the community registry is
- *     unavailable), we fall back to `vss` and `vectorSearch` emits an
- *     explanatory warning; vector queries may then return unfiltered
- *     results on small / highly-selective datasets.
- *   - `fts` (official) — enables `PRAGMA create_fts_index` + `match_bm25`.
- *
- * Timeouts are enforced by a JS-side interrupt timer rather than a DuckDB
- * SQL setting — DuckDB does not expose a per-statement timeout.
+ * Timeouts on `exec` are enforced by a JS-side interrupt timer rather
+ * than a DuckDB SQL setting — DuckDB does not expose a per-statement
+ * timeout.
  */
 
 import {
-  ARRAY,
-  arrayValue,
   type DuckDBConnection,
   DuckDBInstance,
   type DuckDBPreparedStatement,
   FLOAT,
   LIST,
-  listValue,
-  VARCHAR,
 } from "@duckdb/node-api";
-import {
-  type CodeRelation,
-  canonicalJson,
-  type DependencyNode,
-  type FindingNode,
-  type GraphNode,
-  type KnowledgeGraph,
-  type NodeKind,
-  type NodeOfKind,
-  type RelationType,
-  type RepoNode,
-  type RouteNode,
-} from "@opencodehub/core-types";
-import { dedupeLastById, NODE_COLUMNS, nodeToColumns } from "./column-encode.js";
 import type {
-  AncestorTraversalOptions,
-  BulkLoadOptions,
-  BulkLoadStats,
   CochangeLookupOptions,
   CochangeRow,
-  ConsumerProducerEdge,
-  DescendantTraversalOptions,
   EmbeddingRow,
-  GraphDialect,
-  IGraphStore,
   ITemporalStore,
-  ListDependenciesOptions,
-  ListEdgesByTypeOptions,
-  ListEdgesOptions,
-  ListEmbeddingsOptions,
-  ListFindingsOptions,
-  ListNodesByKindOptions,
-  ListNodesByNameOptions,
-  ListNodesOptions,
-  ListRoutesOptions,
-  SearchQuery,
-  SearchResult,
   SqlParam,
-  StoreMeta,
   SymbolSummaryRow,
-  TraverseQuery,
-  TraverseResult,
-  VectorQuery,
-  VectorResult,
 } from "./interface.js";
 import { generateSchemaDDL } from "./schema-ddl.js";
 import { assertReadOnlySql } from "./sql-guard.js";
 
 export interface DuckDbStoreOptions {
   readonly readOnly?: boolean;
-  /** Fixed vector dimension for the `embeddings.vector` column. Default 768. */
+  /**
+   * Retained for API symmetry with the prior multi-tier adapter; the
+   * temporal-only adapter never reads embeddings, so the value is ignored.
+   */
   readonly embeddingDim?: number;
-  /** Default query timeout for `query()` calls in ms. Default 5000. */
+  /** Default query timeout for `exec()` calls in ms. Default 5000. */
   readonly timeoutMs?: number;
 }
 
-const DEFAULT_EMBEDDING_DIM = 768;
 const DEFAULT_TIMEOUT_MS = 5_000;
-// NOTE: widened to `readonly string[]` so new relation names added by the
-// core-types v1.1 migration (FOUND_IN / DEPENDS_ON / OWNED_BY) can be
-// defaulted here without a tight coupling to the compile-time union. Ordering
-// is preserved from the v1.0 list; new types are appended. COCHANGES is no
-// longer in this list — it lives in the dedicated `cochanges` table.
-const ALL_RELATION_TYPES: readonly string[] = [
-  "CONTAINS",
-  "DEFINES",
-  "IMPORTS",
-  "CALLS",
-  "EXTENDS",
-  "IMPLEMENTS",
-  "HAS_METHOD",
-  "HAS_PROPERTY",
-  "ACCESSES",
-  "METHOD_OVERRIDES",
-  "OVERRIDES",
-  "METHOD_IMPLEMENTS",
-  "MEMBER_OF",
-  "PROCESS_STEP",
-  "HANDLES_ROUTE",
-  "FETCHES",
-  "HANDLES_TOOL",
-  "ENTRY_POINT_OF",
-  "WRAPS",
-  "QUERIES",
-  "REFERENCES",
-  "FOUND_IN",
-  "DEPENDS_ON",
-  "OWNED_BY",
-  "TYPE_OF",
-];
-
 const DEFAULT_COCHANGE_LOOKUP_LIMIT = 10;
 const DEFAULT_COCHANGE_MIN_LIFT = 1.0;
 
 /**
- * Concrete adapter that satisfies both {@link IGraphStore} (graph-tier)
- * and {@link ITemporalStore} (tabular-tier) over a single DuckDB
- * connection. The class export remains the legacy bridge type that
- * existing type-pin sites consume; new code should call `openStore(...)`
- * and route through `OpenStoreResult.graph` / `OpenStoreResult.temporal`
- * rather than reaching for the concrete class.
+ * Concrete adapter that satisfies {@link ITemporalStore} over a single
+ * DuckDB connection. Pairs with `GraphDbStore` for the graph tier via
+ * `openStore`.
  */
-export class DuckDbStore implements IGraphStore, ITemporalStore {
-  /**
-   * DuckDB exposes no public Cypher entry point — typed finders cover the
-   * graph reads. Stamped as `"none"` on the {@link IGraphStore.dialect}
-   * marker so callers can branch between Cypher-aware and Cypher-free
-   * adapters.
-   */
-  readonly dialect: GraphDialect = "none";
+export class DuckDbStore implements ITemporalStore {
   private readonly path: string;
   private readonly readOnly: boolean;
-  private readonly embeddingDim: number;
   private readonly defaultTimeoutMs: number;
   private instance: DuckDBInstance | undefined;
   private conn: DuckDBConnection | undefined;
-  private vectorExtension: "hnsw_acorn" | "vss" | "none" = "none";
-  private extensionWarning?: string;
 
   constructor(path: string, opts: DuckDbStoreOptions = {}) {
     this.path = path;
     this.readOnly = opts.readOnly === true;
-    this.embeddingDim = opts.embeddingDim ?? DEFAULT_EMBEDDING_DIM;
     this.defaultTimeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   }
 
@@ -178,15 +77,6 @@ export class DuckDbStore implements IGraphStore, ITemporalStore {
     };
     this.instance = await DuckDBInstance.create(this.path, options);
     this.conn = await this.instance.connect();
-
-    if (!this.readOnly) {
-      await this.loadExtensions();
-    } else {
-      // In read-only mode we can still LOAD (without INSTALL) already-cached
-      // extensions; best-effort so existing indexes remain queryable.
-      await this.tryLoadCachedExtension("hnsw_acorn");
-      await this.tryLoadCachedExtension("fts");
-    }
   }
 
   async close(): Promise<void> {
@@ -198,424 +88,12 @@ export class DuckDbStore implements IGraphStore, ITemporalStore {
 
   async createSchema(): Promise<void> {
     const c = this.requireConn();
-    const stmts = generateSchemaDDL({ embeddingDim: this.embeddingDim });
+    const stmts = generateSchemaDDL();
     for (const stmt of stmts) {
       await c.run(stmt);
     }
   }
 
-  // --------------------------------------------------------------------------
-  // Extensions
-  // --------------------------------------------------------------------------
-
-  private async loadExtensions(): Promise<void> {
-    const c = this.requireConn();
-    // 1. HNSW index. Prefer hnsw_acorn; fall back to stock vss.
-    try {
-      await c.run("INSTALL hnsw_acorn FROM community;");
-      await c.run("LOAD hnsw_acorn;");
-      this.vectorExtension = "hnsw_acorn";
-      // ACORN-1 kicks in only when WHERE-clause selectivity is below this
-      // threshold (default 0.6). On small graphs (e.g. tests, freshly
-      // indexed small repos) selectivity routinely sits above that, so the
-      // planner may skip the filter. Force ACORN always.
-      await c.run("SET hnsw_acorn_threshold = 1.0;");
-      // HNSW indexes are in-memory by default. Enabling this lets us persist
-      // them into the DuckDB file so vector search survives a close/open.
-      await c.run("SET hnsw_enable_experimental_persistence = true;");
-    } catch (firstErr) {
-      try {
-        await c.run("INSTALL vss;");
-        await c.run("LOAD vss;");
-        this.vectorExtension = "vss";
-        await c.run("SET hnsw_enable_experimental_persistence = true;");
-        this.extensionWarning =
-          "hnsw_acorn not available; fell back to vss. Filter-aware vector " +
-          "search may return extra rows on selective WHERE clauses.";
-      } catch (secondErr) {
-        this.vectorExtension = "none";
-        this.extensionWarning =
-          `No HNSW extension available. Vector search disabled. ` +
-          `Causes: ${(firstErr as Error).message} / ${(secondErr as Error).message}`;
-      }
-    }
-    // 2. BM25 full-text search.
-    try {
-      await c.run("INSTALL fts;");
-      await c.run("LOAD fts;");
-    } catch (err) {
-      throw new Error(`Failed to load fts extension: ${(err as Error).message}`);
-    }
-  }
-
-  private async tryLoadCachedExtension(name: string): Promise<void> {
-    const c = this.requireConn();
-    try {
-      await c.run(`LOAD ${name};`);
-      if (name === "hnsw_acorn") this.vectorExtension = "hnsw_acorn";
-    } catch {
-      // swallow — read-only opens shouldn't fail because an extension is missing
-    }
-  }
-
-  /** Surface the warning so callers can log it. Undefined if everything loaded. */
-  getExtensionWarning(): string | undefined {
-    return this.extensionWarning;
-  }
-
-  // --------------------------------------------------------------------------
-  // Bulk load
-  // --------------------------------------------------------------------------
-
-  async bulkLoad(graph: KnowledgeGraph, opts: BulkLoadOptions = {}): Promise<BulkLoadStats> {
-    const c = this.requireConn();
-    const started = performance.now();
-    const mode = opts.mode ?? "replace";
-
-    await c.run("BEGIN TRANSACTION");
-    try {
-      if (mode === "replace") {
-        await c.run("DELETE FROM nodes");
-        await c.run("DELETE FROM relations");
-        await c.run("DELETE FROM cochanges");
-      }
-
-      // DuckDB UPSERT issue 8147: rows that collide on the primary key inside
-      // a single INSERT are ambiguous. Dedupe the batch first so ON CONFLICT
-      // only has to reconcile against already-persisted rows. This is also
-      // safe for "replace" mode — the graph's `orderedNodes` already dedupes
-      // by id, but we keep the call here so the invariant is explicit.
-      const orderedNodes = dedupeLastById(graph.orderedNodes(), (n) => n.id);
-      if (orderedNodes.length > 0) {
-        await this.insertNodes(orderedNodes, mode);
-      }
-
-      const orderedEdges = dedupeLastById(graph.orderedEdges(), (e) => e.id);
-      if (orderedEdges.length > 0) {
-        await this.insertEdges(orderedEdges, mode);
-      }
-
-      await c.run("COMMIT");
-    } catch (err) {
-      await c.run("ROLLBACK");
-      throw err;
-    }
-
-    await this.buildPostLoadIndexes();
-
-    const durationMs = performance.now() - started;
-    return {
-      nodeCount: graph.nodeCount(),
-      edgeCount: graph.edgeCount(),
-      durationMs,
-    };
-  }
-
-  private async insertNodes(
-    nodes: readonly GraphNode[],
-    mode: "replace" | "upsert",
-  ): Promise<void> {
-    const c = this.requireConn();
-    // Keep in sync with schema-ddl.ts. Order matters: `NODE_COLUMNS[0]` must
-    // be "id" so the ON CONFLICT target aligns with the primary key and the
-    // DO UPDATE SET clause below skips slot 0.
-    const columnList = NODE_COLUMNS.join(", ");
-    const placeholders = NODE_COLUMNS.map(() => "?").join(", ");
-    // DuckDB UPSERT issue 16698: never SET `id = excluded.id` in the DO
-    // UPDATE clause — it causes silent corruption. We build the update list
-    // from every column EXCEPT id.
-    const updateAssignments = NODE_COLUMNS.slice(1)
-      .map((col) => `${col} = excluded.${col}`)
-      .join(", ");
-    const sql =
-      mode === "upsert"
-        ? `INSERT INTO nodes (${columnList}) VALUES (${placeholders})
-           ON CONFLICT (id) DO UPDATE SET ${updateAssignments}`
-        : `INSERT INTO nodes (${columnList}) VALUES (${placeholders})`;
-
-    const stmt = await c.prepare(sql);
-    try {
-      for (const node of nodes) {
-        stmt.clearBindings();
-        const row = nodeToRow(node);
-        for (let i = 0; i < row.length; i += 1) {
-          bindParam(stmt, i + 1, row[i] ?? null);
-        }
-        await stmt.run();
-      }
-    } finally {
-      stmt.destroySync();
-    }
-  }
-
-  private async insertEdges(
-    edges: readonly {
-      readonly id: string;
-      readonly from: string;
-      readonly to: string;
-      readonly type: RelationType;
-      readonly confidence: number;
-      readonly reason?: string;
-      readonly step?: number;
-    }[],
-    mode: "replace" | "upsert",
-  ): Promise<void> {
-    const c = this.requireConn();
-    const sql =
-      mode === "upsert"
-        ? `INSERT INTO relations (id, from_id, to_id, type, confidence, reason, step)
-           VALUES (?, ?, ?, ?, ?, ?, ?)
-           ON CONFLICT (id) DO UPDATE SET
-             from_id = excluded.from_id,
-             to_id = excluded.to_id,
-             type = excluded.type,
-             confidence = excluded.confidence,
-             reason = excluded.reason,
-             step = excluded.step`
-        : "INSERT INTO relations (id, from_id, to_id, type, confidence, reason, step) VALUES (?, ?, ?, ?, ?, ?, ?)";
-    const stmt = await c.prepare(sql);
-    try {
-      for (const e of edges) {
-        stmt.clearBindings();
-        bindParam(stmt, 1, e.id);
-        bindParam(stmt, 2, e.from);
-        bindParam(stmt, 3, e.to);
-        bindParam(stmt, 4, e.type);
-        bindParam(stmt, 5, e.confidence);
-        bindParam(stmt, 6, e.reason ?? null);
-        bindParam(stmt, 7, e.step ?? 0);
-        await stmt.run();
-      }
-    } finally {
-      stmt.destroySync();
-    }
-  }
-
-  private async buildPostLoadIndexes(): Promise<void> {
-    if (this.readOnly) return;
-    const c = this.requireConn();
-    // FTS over the polymorphic nodes table. Must be rebuilt after rows change.
-    // PRAGMA drop is idempotent-friendly via `overwrite=1`.
-    await c.run(
-      "PRAGMA create_fts_index('nodes', 'id', 'name', 'signature', 'description', overwrite=1);",
-    );
-    // HNSW vector index — only meaningful once the extension is loaded and
-    // at least one embedding row exists.
-    if (this.vectorExtension !== "none") {
-      const countReader = await c.runAndReadAll("SELECT COUNT(*) AS n FROM embeddings");
-      const rows = countReader.getRowObjects();
-      const first = rows[0];
-      const n = first ? Number((first as { n: unknown }).n) : 0;
-      if (n > 0) {
-        await c.run(
-          "CREATE INDEX IF NOT EXISTS idx_embeddings_vec ON embeddings USING HNSW (vector);",
-        );
-      }
-    }
-  }
-
-  // --------------------------------------------------------------------------
-  // Embeddings
-  // --------------------------------------------------------------------------
-
-  async upsertEmbeddings(rows: readonly EmbeddingRow[]): Promise<void> {
-    if (rows.length === 0) return;
-    const c = this.requireConn();
-    const dim = this.embeddingDim;
-    const arrType = ARRAY(FLOAT, dim);
-
-    await c.run("BEGIN TRANSACTION");
-    try {
-      // Remove any pre-existing rows with matching (node_id, granularity,
-      // chunk_index) so this method is effectively an upsert. The id column
-      // encodes granularity now (`Emb:<tier>:<nodeId>:<chunkIndex>`) so two
-      // tiers pointing at the same underlying node never collide on the
-      // primary key.
-      const delStmt = await c.prepare(
-        "DELETE FROM embeddings WHERE node_id = ? AND granularity = ? AND chunk_index = ?",
-      );
-      try {
-        for (const r of rows) {
-          const granularity = r.granularity ?? "symbol";
-          delStmt.clearBindings();
-          delStmt.bindVarchar(1, r.nodeId);
-          delStmt.bindVarchar(2, granularity);
-          delStmt.bindInteger(3, r.chunkIndex);
-          await delStmt.run();
-        }
-      } finally {
-        delStmt.destroySync();
-      }
-
-      const insStmt = await c.prepare(
-        "INSERT INTO embeddings (id, node_id, granularity, chunk_index, start_line, end_line, vector, content_hash) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
-      );
-      try {
-        for (const r of rows) {
-          if (r.vector.length !== dim) {
-            throw new Error(
-              `Embedding dimension mismatch: got ${r.vector.length}, expected ${dim}`,
-            );
-          }
-          const granularity = r.granularity ?? "symbol";
-          insStmt.clearBindings();
-          // Id includes the tier so cross-tier collisions on `(nodeId,
-          // chunkIndex)` are impossible. Legacy rows produced before P03
-          // used `Emb:<nodeId>:<chunkIndex>`; DuckDB lets two rows coexist
-          // across schema versions as long as the PK is unique within the
-          // on-disk file, which this scheme guarantees.
-          insStmt.bindVarchar(1, `Emb:${granularity}:${r.nodeId}:${r.chunkIndex}`);
-          insStmt.bindVarchar(2, r.nodeId);
-          insStmt.bindVarchar(3, granularity);
-          insStmt.bindInteger(4, r.chunkIndex);
-          bindParam(insStmt, 5, r.startLine ?? null);
-          bindParam(insStmt, 6, r.endLine ?? null);
-          insStmt.bindArray(7, arrayValue(Array.from(r.vector)), arrType);
-          insStmt.bindVarchar(8, r.contentHash);
-          await insStmt.run();
-        }
-      } finally {
-        insStmt.destroySync();
-      }
-
-      await c.run("COMMIT");
-    } catch (err) {
-      await c.run("ROLLBACK");
-      throw err;
-    }
-  }
-
-  /**
-   * @internal
-   * Stream the `embeddings` table to a Parquet file via DuckDB's built-in
-   * `COPY ... TO ... (FORMAT PARQUET, COMPRESSION ZSTD)`. Backs the
-   * Parquet sidecar BOM item for `@opencodehub/pack`.
-   *
-   * **NOT part of the public storage surface.** The embeddings sidecar is
-   * a packaging concern owned by `@opencodehub/pack`. This method survives
-   * as a DuckDB-only helper that pack's `writeEmbeddingsSidecar` invokes
-   * after narrowing `store.temporal` (or
-   * `store.graph` when `backend === "duck"`) to a {@link DuckDbStore}.
-   * Third-party {@link IGraphStore} / {@link ITemporalStore} implementations
-   * MUST NOT implement it — pack stamps `determinismClass: "degraded"`
-   * automatically when the helper is unreachable.
-   *
-   * Determinism contract — must hold byte-for-byte across two runs against
-   * the same on-disk DuckDB file:
-   *   - Row ordering is `node_id ASC, granularity ASC, chunk_index ASC`. The
-   *     COPY pipes the SELECT result directly so the Parquet row groups
-   *     materialize in that order.
-   *   - ZSTD compression at the DuckDB default level. The default is
-   *     deterministic; do NOT pass an explicit level — that would couple the
-   *     output to whichever level the caller picked and risk byte drift.
-   *   - DuckDB v1.3.0+ ("Ossivalis") rewrote the parquet writer to drop the
-   *     implicit timestamps that previously broke byte-identity. The
-   *     `created_by` metadata still embeds the engine version string, so we
-   *     surface that string to the caller via `duckdbVersion` and the pack
-   *     manifest pins it (`PackPins.duckdbVersion`).
-   *
-   * When the embeddings table is empty, NO file is written; the caller
-   * is expected to skip the BomItem entirely.
-   *
-   * Caller MUST pass an absolute path. Path is interpolated into the SQL
-   * statement after a strict format check (alphanumerics + `/_-.` only and
-   * leading `/` required) so injection attempts via path-as-input are
-   * blocked. We do not parameterize the COPY target because DuckDB's
-   * prepared-statement parser does not bind COPY destinations.
-   */
-  async exportEmbeddingsParquet(
-    absOutPath: string,
-  ): Promise<{ readonly rowCount: number; readonly duckdbVersion: string }> {
-    const c = this.requireConn();
-    const duckdbVersion = await this.fetchDuckdbVersion();
-
-    const countReader = await c.runAndReadAll("SELECT COUNT(*) AS n FROM embeddings");
-    const countRows = countReader.getRowObjects();
-    const first = countRows[0];
-    const rowCount = first ? Number((first as { n: unknown }).n) : 0;
-
-    if (rowCount === 0) {
-      return { rowCount: 0, duckdbVersion };
-    }
-
-    if (!isSafeAbsolutePath(absOutPath)) {
-      throw new Error(
-        "exportEmbeddingsParquet: outPath must be an absolute path with safe characters " +
-          "(alphanumerics, slash, underscore, dash, dot)",
-      );
-    }
-
-    // COPY does not accept bound parameters for the destination. The path
-    // has been validated above so single-quote injection is impossible
-    // (the safe-path regex rejects quotes outright).
-    const sql =
-      `COPY (SELECT node_id, granularity, chunk_index, vector ` +
-      `FROM embeddings ORDER BY node_id ASC, granularity ASC, chunk_index ASC) ` +
-      `TO '${absOutPath}' (FORMAT PARQUET, COMPRESSION ZSTD)`;
-    await c.run(sql);
-    return { rowCount, duckdbVersion };
-  }
-
-  /**
-   * Resolve the live DuckDB engine version via `SELECT version()`. The
-   * result is the string DuckDB embeds in the parquet `created_by`
-   * metadata, so the pack manifest's `pins.duckdbVersion` stays bound to
-   * the writer version that produced the sidecar.
-   *
-   * Defensive: returns `"unknown"` if the call fails or returns a non-string
-   * — older bindings have been observed to return a struct value here.
-   */
-  private async fetchDuckdbVersion(): Promise<string> {
-    const c = this.requireConn();
-    try {
-      const reader = await c.runAndReadAll("SELECT version() AS v");
-      const rows = reader.getRowObjects();
-      const v = rows[0] ? (rows[0] as { v?: unknown }).v : undefined;
-      return typeof v === "string" && v.length > 0 ? v : "unknown";
-    } catch {
-      return "unknown";
-    }
-  }
-
-  /**
-   * Load every prior `content_hash` from the `embeddings` table keyed by the
-   * composite `(granularity, node_id, chunk_index)` tuple. Used by the
-   * ingestion embeddings phase to skip re-embedding chunks whose source
-   * text is unchanged across runs.
-   *
-   * A single `SELECT` round-trip is cheaper than per-chunk lookups and
-   * keeps the API surface narrow: the caller gets a `Map` it owns.
-   *
-   * Key format: `${granularity}\0${node_id}\0${chunk_index}` — binary-safe
-   * vs `:` which appears inside NodeIds. Matches the key encoding the
-   * embeddings phase uses when probing for hits.
-   */
-  async listEmbeddingHashes(): Promise<Map<string, string>> {
-    const c = this.requireConn();
-    const reader = await c.runAndReadAll(
-      "SELECT node_id, granularity, chunk_index, content_hash FROM embeddings",
-    );
-    const rows = reader.getRowObjects();
-    const out = new Map<string, string>();
-    for (const row of rows) {
-      const nodeId = row["node_id"];
-      const granularity = row["granularity"];
-      const chunkIndex = row["chunk_index"];
-      const contentHash = row["content_hash"];
-      if (
-        typeof nodeId !== "string" ||
-        typeof granularity !== "string" ||
-        typeof contentHash !== "string" ||
-        (typeof chunkIndex !== "number" && typeof chunkIndex !== "bigint")
-      ) {
-        continue;
-      }
-      const ci = typeof chunkIndex === "bigint" ? Number(chunkIndex) : chunkIndex;
-      out.set(`${granularity}\0${nodeId}\0${ci}`, contentHash);
-    }
-    return out;
-  }
-
   // --------------------------------------------------------------------------
   // Cochanges
   // --------------------------------------------------------------------------
@@ -630,7 +108,7 @@ export class DuckDbStore implements IGraphStore, ITemporalStore {
         return;
       }
       // Sort by (source_file, target_file) so insertion order is deterministic
-      // across runs — matches the ordering discipline used for nodes/edges.
+      // across runs.
       const sorted = [...rows].sort((a, b) => {
         if (a.sourceFile !== b.sourceFile) {
           return a.sourceFile < b.sourceFile ? -1 : 1;
@@ -737,7 +215,7 @@ export class DuckDbStore implements IGraphStore, ITemporalStore {
     if (rows.length === 0) return;
     const c = this.requireConn();
     // Sort by the composite primary key so insertion order is deterministic
-    // across runs — mirrors the cochanges / nodes / relations pattern.
+    // across runs.
     const sorted = [...rows].sort((a, b) => {
       if (a.nodeId !== b.nodeId) return a.nodeId < b.nodeId ? -1 : 1;
       if (a.contentHash !== b.contentHash) return a.contentHash < b.contentHash ? -1 : 1;
@@ -851,38 +329,11 @@ export class DuckDbStore implements IGraphStore, ITemporalStore {
     }
   }
 
-  /**
-   * Batched query-path join helper: fetch summaries for many nodes in one
-   * round trip, returning the newest prompt-version row per node. Built on
-   * top of {@link lookupSymbolSummariesByNode} — that method returns rows
-   * ordered by `(node_id, prompt_version, content_hash)`, so collapsing to
-   * the last row per `node_id` yields the newest prompt version.
-   *
-   * This is the surface the MCP `query` tool and the CLI `query` command
-   * use to enrich search hits with summaries post-P04. The single-row
-   * {@link lookupSymbolSummary} remains the cache-probe surface used by
-   * the ingestion phase.
-   */
-  async getSymbolSummariesByNodeIds(
-    ids: readonly string[],
-  ): Promise<Map<string, SymbolSummaryRow>> {
-    const out = new Map<string, SymbolSummaryRow>();
-    if (ids.length === 0) return out;
-    const uniqIds = Array.from(new Set(ids));
-    const rows = await this.lookupSymbolSummariesByNode(uniqIds);
-    for (const row of rows) {
-      // Rows arrive sorted by (node_id ASC, prompt_version ASC). Overwriting
-      // on each id keeps the newest prompt version after the full scan.
-      out.set(row.nodeId, row);
-    }
-    return out;
-  }
-
   // --------------------------------------------------------------------------
-  // Query surfaces
+  // exec — read-only SQL escape hatch (codehub query --sql, MCP sql tool)
   // --------------------------------------------------------------------------
 
-  async query(
+  async exec(
     sql: string,
     params: readonly SqlParam[] = [],
     opts: { readonly timeoutMs?: number } = {},
@@ -904,1115 +355,130 @@ export class DuckDbStore implements IGraphStore, ITemporalStore {
     });
   }
 
-  /**
-   * {@link ITemporalStore.exec} implementation — delegates to {@link query}.
-   * Callers that route through `OpenStoreResult.temporal` use this name;
-   * the original `query()` method stays for legacy type-pin sites that
-   * still consume the merged surface.
-   */
-  async exec(
-    sql: string,
-    params: readonly SqlParam[] = [],
-    opts: { readonly timeoutMs?: number } = {},
-  ): Promise<readonly Record<string, unknown>[]> {
-    return this.query(sql, params, opts);
-  }
+  // --------------------------------------------------------------------------
+  // Embedding-Parquet export — pack/embeddings-sidecar.ts surface
+  //
+  // Embeddings live in `graph.lbug`. The sidecar streams rows out of lbug,
+  // stages them in a per-call DuckDB temp table on `temporal.duckdb`, then
+  // runs `COPY (...) TO '<path>' (FORMAT PARQUET, COMPRESSION ZSTD)` to
+  // produce the byte-identical sidecar. The temp table is connection-local
+  // and dropped before the call returns.
+  // --------------------------------------------------------------------------
 
-  /**
-   * Enumerate fully-rehydrated GraphNodes by kind. Backs the M5 BOM bodies
-   * (skeleton, file-tree, deps, xrefs) so they can iterate typed nodes
-   * without scattering raw SELECT statements across `packages/pack/`.
-   *
-   * The polymorphic `nodes` table stores wider columns than `NodeBase`
-   * (e.g. `version` / `license` / `lockfile_source` / `ecosystem` for
-   * Dependency rows; `repo_uri` / `default_branch` / etc. for Repo rows).
-   * `SELECT *` is unsafe across kinds because callers downstream rely on
-   * field absence to discriminate, so we enumerate every column explicitly
-   * and rehydrate via {@link rowToGraphNode}.
-   *
-   * Determinism: ORDER BY id ASC at the SQL layer + a JS-side lex-stable
-   * tiebreak, matching the GraphDbStore implementation byte-for-byte.
-   */
-  async listNodes(opts: ListNodesOptions = {}): Promise<readonly GraphNode[]> {
+  async exportEmbeddingsToParquet(
+    rows: AsyncIterable<EmbeddingRow>,
+    absOutPath: string,
+  ): Promise<{ readonly rowCount: number; readonly duckdbVersion: string }> {
     const c = this.requireConn();
-    const kinds = opts.kinds;
-    // Empty-kinds short-circuit. The contract is "kinds: [] returns []";
-    // we never even hit SQL so the round-trip is free.
-    if (kinds !== undefined && kinds.length === 0) return [];
-    // Same short-circuit semantics for `ids`: an empty array means "no
-    // ids match". Adapters de-dupe on the input set so callers can pass
-    // a list with repeats.
-    const idsRaw = opts.ids;
-    if (idsRaw !== undefined && idsRaw.length === 0) return [];
-    const ids = idsRaw !== undefined ? Array.from(new Set(idsRaw)) : undefined;
-    const limit = clampNonNegativeInt(opts.limit);
-    const offset = clampNonNegativeInt(opts.offset);
+    const duckdbVersion = await this.fetchDuckdbVersion();
 
-    const columnList = NODE_COLUMNS.join(", ");
-    const wheres: string[] = [];
-    if (kinds && kinds.length > 0) {
-      wheres.push(`kind IN (${kinds.map(() => "?").join(", ")})`);
-    }
-    if (ids !== undefined && ids.length > 0) {
-      wheres.push(`id IN (${ids.map(() => "?").join(", ")})`);
-    }
-    if (opts.filePath !== undefined) {
-      wheres.push("file_path = ?");
+    if (!isSafeAbsolutePath(absOutPath)) {
+      throw new Error(
+        "exportEmbeddingsToParquet: outPath must be an absolute path with safe characters " +
+          "(alphanumerics, slash, underscore, dash, dot)",
+      );
     }
-    const whereClause = wheres.length > 0 ? `WHERE ${wheres.join(" AND ")}` : "";
-    // ORDER BY id ASC at the SQL layer; LIMIT/OFFSET applied after the
-    // filter so paging stays stable across calls. Both clauses are omitted
-    // when their values are undefined so the prepared statement plan
-    // stays minimal for the common "list everything" case.
-    const limitClause = limit !== undefined ? "LIMIT ?" : "";
-    const offsetClause = offset !== undefined ? "OFFSET ?" : "";
-    const sql = (
-      `SELECT ${columnList} FROM nodes ${whereClause} ` +
-      `ORDER BY id ASC ${limitClause} ${offsetClause}`
-    ).trim();
 
-    const stmt = await c.prepare(sql);
+    // Pre-staging: create a transient table sized to the largest VECTOR width
+    // we'll see. DuckDB temp tables are connection-scoped — a stale handle
+    // from a prior call would surface as a "table already exists" error, so
+    // drop defensively before recreating.
+    await c.run("DROP TABLE IF EXISTS embeddings_export");
+    await c.run(
+      "CREATE TEMP TABLE embeddings_export (" +
+        "node_id VARCHAR NOT NULL, " +
+        "granularity VARCHAR NOT NULL, " +
+        "chunk_index INTEGER NOT NULL, " +
+        "vector FLOAT[] NOT NULL" +
+        ")",
+    );
+
+    let rowCount = 0;
     try {
-      let idx = 1;
-      if (kinds) {
-        for (const k of kinds) {
-          stmt.bindVarchar(idx++, k);
-        }
-      }
-      if (ids !== undefined) {
-        for (const id of ids) {
-          stmt.bindVarchar(idx++, id);
+      const insertStmt = await c.prepare(
+        "INSERT INTO embeddings_export (node_id, granularity, chunk_index, vector) VALUES (?, ?, ?, ?)",
+      );
+      try {
+        for await (const row of rows) {
+          insertStmt.bindVarchar(1, row.nodeId);
+          insertStmt.bindVarchar(2, row.granularity ?? "symbol");
+          insertStmt.bindInteger(3, row.chunkIndex);
+          insertStmt.bindList(4, Array.from(row.vector), LIST(FLOAT));
+          await insertStmt.run();
+          rowCount += 1;
         }
+      } finally {
+        // No public destroy on prepared statements in the current binding;
+        // they're cleaned up when the connection closes.
       }
-      if (opts.filePath !== undefined) {
-        stmt.bindVarchar(idx++, opts.filePath);
-      }
-      if (limit !== undefined) stmt.bindInteger(idx++, limit);
-      if (offset !== undefined) stmt.bindInteger(idx++, offset);
-      const reader = await stmt.runAndReadAll();
-      const raw = normalizeRows(reader.getRowObjects());
-      const out: GraphNode[] = [];
-      for (const row of raw) {
-        const node = rowToGraphNode(row);
-        if (node) out.push(node);
+
+      if (rowCount === 0) {
+        return { rowCount: 0, duckdbVersion };
       }
-      // Lex-stable tiebreak on id so both adapters agree byte-for-byte even
-      // when the underlying engine's sort collation diverges (DuckDB uses
-      // bytewise ASCII; the graph-db engine returns rows in primary-key
-      // order which can vary across versions).
-      return [...out].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+
+      // COPY does not accept bound parameters for the destination. The path
+      // is validated above so single-quote injection is impossible.
+      const sql =
+        `COPY (SELECT node_id, granularity, chunk_index, vector ` +
+        `FROM embeddings_export ORDER BY node_id ASC, granularity ASC, chunk_index ASC) ` +
+        `TO '${absOutPath}' (FORMAT PARQUET, COMPRESSION ZSTD)`;
+      await c.run(sql);
+      return { rowCount, duckdbVersion };
     } finally {
-      stmt.destroySync();
+      await c.run("DROP TABLE IF EXISTS embeddings_export").catch(() => {});
     }
   }
 
-  // --------------------------------------------------------------------------
-  // Typed finders — service-layer foundation
-  // --------------------------------------------------------------------------
-  //
-  // Every method below replaces a raw-SQL pattern that consumers used to
-  // reach for. SQL strings stay LOCAL to this file — they are never
-  // exported from the package surface so consumers cannot reach for the
-  // dialect directly.
-  //
-  // Determinism contract: every finder returns rows in deterministic order so
-  // two calls against the same on-disk graph produce byte-identical output.
-  // Node finders order by `id ASC`; edge finders order by `(from_id, to_id,
-  // type)`; the consumer-producer finder orders by
-  // `(consumer_repo_uri, producer_repo_uri, http_method, http_path)`.
-
   /**
-   * Single-kind shorthand. Implemented as a thin wrapper around the
-   * existing column-keyed `SELECT ${NODE_COLUMNS} FROM nodes` plus
-   * `filePath`/`filePathLike` predicates. Returns rehydrated typed
-   * nodes via {@link rowToGraphNode}.
+   * Resolve the live DuckDB engine version via `SELECT version()`. The
+   * result is the string DuckDB embeds in the parquet `created_by`
+   * metadata, so the pack manifest's `pins.duckdbVersion` stays bound to
+   * the writer version that produced the sidecar.
    */
-  async listNodesByKind<K extends NodeKind>(
-    kind: K,
-    opts: ListNodesByKindOptions = {},
-  ): Promise<readonly NodeOfKind<K>[]> {
+  private async fetchDuckdbVersion(): Promise<string> {
     const c = this.requireConn();
-    const limit = clampNonNegativeInt(opts.limit);
-    const offset = clampNonNegativeInt(opts.offset);
-    const columnList = NODE_COLUMNS.join(", ");
-
-    const wheres: string[] = ["kind = ?"];
-    const binds: SqlParam[] = [kind];
-    if (opts.filePath !== undefined) {
-      wheres.push("file_path = ?");
-      binds.push(opts.filePath);
-    }
-    if (opts.filePathLike !== undefined) {
-      wheres.push("file_path LIKE ?");
-      binds.push(`%${opts.filePathLike}%`);
+    try {
+      const reader = await c.runAndReadAll("SELECT version() AS v");
+      const rows = reader.getRowObjects();
+      const v = rows[0] ? (rows[0] as { v?: unknown }).v : undefined;
+      return typeof v === "string" && v.length > 0 ? v : "unknown";
+    } catch {
+      return "unknown";
     }
-    const limitClause = limit !== undefined ? "LIMIT ?" : "";
-    const offsetClause = offset !== undefined ? "OFFSET ?" : "";
-    const sql = (
-      `SELECT ${columnList} FROM nodes WHERE ${wheres.join(" AND ")} ` +
-      `ORDER BY id ASC ${limitClause} ${offsetClause}`
-    ).trim();
+  }
+
+  // --------------------------------------------------------------------------
+  // healthCheck
+  // --------------------------------------------------------------------------
 
-    const stmt = await c.prepare(sql);
+  async healthCheck(): Promise<{ ok: boolean; message?: string }> {
     try {
-      let idx = 1;
-      for (const b of binds) bindParam(stmt, idx++, b);
-      if (limit !== undefined) stmt.bindInteger(idx++, limit);
-      if (offset !== undefined) stmt.bindInteger(idx++, offset);
-      const reader = await stmt.runAndReadAll();
-      const raw = normalizeRows(reader.getRowObjects());
-      const out: GraphNode[] = [];
-      for (const row of raw) {
-        const node = rowToGraphNode(row);
-        if (node) out.push(node);
-      }
-      // Lex-stable tiebreak on id matches `listNodes` so cross-adapter
-      // parity holds.
-      const sorted = [...out].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
-      // Cast through `unknown`: the SQL filter pinned `kind = K` so every
-      // surviving row's `kind` discriminator equals K, but TS can't widen
-      // a discriminated-union narrow through an array of GraphNode without
-      // help. The structural invariant is enforced above.
-      return sorted as unknown as readonly NodeOfKind<K>[];
-    } finally {
-      stmt.destroySync();
+      const c = this.requireConn();
+      const reader = await c.runAndReadAll("SELECT 1 AS ok");
+      const rows = reader.getRowObjects();
+      const first = rows[0];
+      const ok = first ? Number((first as { ok: unknown }).ok) === 1 : false;
+      return ok ? { ok: true } : { ok: false, message: "SELECT 1 returned unexpected shape" };
+    } catch (err) {
+      return { ok: false, message: (err as Error).message };
     }
   }
 
-  /**
-   * All edges, optionally filtered + paged. Result rows are typed
-   * {@link CodeRelation}s. Determinism: ORDER BY `(from_id, to_id, type)`.
-   */
-  async listEdges(opts: ListEdgesOptions = {}): Promise<readonly CodeRelation[]> {
-    const c = this.requireConn();
-    return this.listEdgesInternal(c, opts);
-  }
+  // --------------------------------------------------------------------------
+  // Internal helpers
+  // --------------------------------------------------------------------------
 
-  /**
-   * Single-type shorthand. Lifts onto {@link listEdges} with the type
-   * pinned. Same ordering contract.
-   */
-  async listEdgesByType(
-    type: RelationType,
-    opts: ListEdgesByTypeOptions = {},
-  ): Promise<readonly CodeRelation[]> {
-    const merged: ListEdgesOptions = {
-      types: [type],
-      ...(opts.fromIds !== undefined ? { fromIds: opts.fromIds } : {}),
-      ...(opts.toIds !== undefined ? { toIds: opts.toIds } : {}),
-      ...(opts.minConfidence !== undefined ? { minConfidence: opts.minConfidence } : {}),
-      ...(opts.limit !== undefined ? { limit: opts.limit } : {}),
-    };
-    return this.listEdges(merged);
+  private requireConn(): DuckDBConnection {
+    if (!this.conn) {
+      throw new Error("DuckDbStore is not open — call open() first");
+    }
+    return this.conn;
   }
 
   /**
-   * Findings filter. Materializes typed {@link FindingNode}s — the
-   * underlying row goes through {@link rowToGraphNode} so wider columns
-   * (`baseline_state`, `suppressed_json`, `properties_bag`) come back
-   * with the same shape callers see when they read a Finding via
-   * `listNodes`.
-   */
-  async listFindings(opts: ListFindingsOptions = {}): Promise<readonly FindingNode[]> {
-    const c = this.requireConn();
-    const wheres: string[] = ["kind = 'Finding'"];
-    const binds: SqlParam[] = [];
-    if (opts.severity && opts.severity.length > 0) {
-      const ph = opts.severity.map(() => "?").join(", ");
-      wheres.push(`severity IN (${ph})`);
-      for (const s of opts.severity) binds.push(s);
-    }
-    if (opts.ruleId !== undefined) {
-      wheres.push("rule_id = ?");
-      binds.push(opts.ruleId);
-    }
-    if (opts.baselineState && opts.baselineState.length > 0) {
-      const ph = opts.baselineState.map(() => "?").join(", ");
-      wheres.push(`baseline_state IN (${ph})`);
-      for (const s of opts.baselineState) binds.push(s);
-    }
-    if (opts.suppressed === true) {
-      wheres.push("suppressed_json IS NOT NULL");
-    } else if (opts.suppressed === false) {
-      wheres.push("suppressed_json IS NULL");
-    }
-    const limit = clampNonNegativeInt(opts.limit);
-    const limitClause = limit !== undefined ? "LIMIT ?" : "";
-    const columnList = NODE_COLUMNS.join(", ");
-    const sql = (
-      `SELECT ${columnList} FROM nodes WHERE ${wheres.join(" AND ")} ` +
-      `ORDER BY id ASC ${limitClause}`
-    ).trim();
-    const stmt = await c.prepare(sql);
-    try {
-      let idx = 1;
-      for (const b of binds) bindParam(stmt, idx++, b);
-      if (limit !== undefined) stmt.bindInteger(idx++, limit);
-      const reader = await stmt.runAndReadAll();
-      const raw = normalizeRows(reader.getRowObjects());
-      const out: FindingNode[] = [];
-      for (const row of raw) {
-        const node = rowToGraphNode(row);
-        if (node && node.kind === "Finding") out.push(node as FindingNode);
-      }
-      return [...out].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
-    } finally {
-      stmt.destroySync();
-    }
-  }
-
-  /**
-   * Dependencies filter. `licenseTier` is treated as a license-tier
-   * pre-classification: the caller supplies the bucket(s) of interest
-   * and the adapter joins through a lightweight in-method classifier
-   * keyed on the SPDX `license` column. The classifier rules mirror
-   * the OCH license-audit table so {@link listDependencies} returns
-   * the same set the audit surface reports for that tier.
-   */
-  async listDependencies(opts: ListDependenciesOptions = {}): Promise<readonly DependencyNode[]> {
-    const c = this.requireConn();
-    const wheres: string[] = ["kind = 'Dependency'"];
-    const binds: SqlParam[] = [];
-    if (opts.ecosystem !== undefined) {
-      wheres.push("ecosystem = ?");
-      binds.push(opts.ecosystem);
-    }
-    const limit = clampNonNegativeInt(opts.limit);
-    const limitClause = limit !== undefined ? "LIMIT ?" : "";
-    const columnList = NODE_COLUMNS.join(", ");
-    const sql = (
-      `SELECT ${columnList} FROM nodes WHERE ${wheres.join(" AND ")} ` +
-      `ORDER BY id ASC ${limitClause}`
-    ).trim();
-    const stmt = await c.prepare(sql);
-    try {
-      let idx = 1;
-      for (const b of binds) bindParam(stmt, idx++, b);
-      if (limit !== undefined) stmt.bindInteger(idx++, limit);
-      const reader = await stmt.runAndReadAll();
-      const raw = normalizeRows(reader.getRowObjects());
-      const out: DependencyNode[] = [];
-      const tierSet =
-        opts.licenseTier && opts.licenseTier.length > 0 ? new Set(opts.licenseTier) : undefined;
-      for (const row of raw) {
-        const node = rowToGraphNode(row);
-        if (!node || node.kind !== "Dependency") continue;
-        if (tierSet) {
-          const tier = classifyLicenseTier((node as DependencyNode).license);
-          if (!tierSet.has(tier)) continue;
-        }
-        out.push(node as DependencyNode);
-      }
-      return [...out].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
-    } finally {
-      stmt.destroySync();
-    }
-  }
-
-  /** Routes filter. Methods + URL `pathLike` predicates. */
-  async listRoutes(opts: ListRoutesOptions = {}): Promise<readonly RouteNode[]> {
-    const c = this.requireConn();
-    const wheres: string[] = ["kind = 'Route'"];
-    const binds: SqlParam[] = [];
-    if (opts.methods && opts.methods.length > 0) {
-      const ph = opts.methods.map(() => "?").join(", ");
-      wheres.push(`method IN (${ph})`);
-      for (const m of opts.methods) binds.push(m);
-    }
-    if (opts.pathLike !== undefined) {
-      wheres.push("url LIKE ?");
-      binds.push(`%${opts.pathLike}%`);
-    }
-    const limit = clampNonNegativeInt(opts.limit);
-    const limitClause = limit !== undefined ? "LIMIT ?" : "";
-    const columnList = NODE_COLUMNS.join(", ");
-    const sql = (
-      `SELECT ${columnList} FROM nodes WHERE ${wheres.join(" AND ")} ` +
-      `ORDER BY id ASC ${limitClause}`
-    ).trim();
-    const stmt = await c.prepare(sql);
-    try {
-      let idx = 1;
-      for (const b of binds) bindParam(stmt, idx++, b);
-      if (limit !== undefined) stmt.bindInteger(idx++, limit);
-      const reader = await stmt.runAndReadAll();
-      const raw = normalizeRows(reader.getRowObjects());
-      const out: RouteNode[] = [];
-      for (const row of raw) {
-        const node = rowToGraphNode(row);
-        if (node && node.kind === "Route") out.push(node as RouteNode);
-      }
-      return [...out].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
-    } finally {
-      stmt.destroySync();
-    }
-  }
-
-  /**
-   * Repo-node by id. Returns `undefined` when no row matches OR when the
-   * row is not `kind = 'Repo'` (the caller never has to downcast).
-   */
-  async getRepoNode(id: string): Promise<RepoNode | undefined> {
-    const c = this.requireConn();
-    const columnList = NODE_COLUMNS.join(", ");
-    const stmt = await c.prepare(
-      `SELECT ${columnList} FROM nodes WHERE id = ? AND kind = 'Repo' LIMIT 1`,
-    );
-    try {
-      stmt.bindVarchar(1, id);
-      const reader = await stmt.runAndReadAll();
-      const raw = normalizeRows(reader.getRowObjects());
-      const first = raw[0];
-      if (!first) return undefined;
-      const node = rowToGraphNode(first);
-      if (!node || node.kind !== "Repo") return undefined;
-      return node as RepoNode;
-    } finally {
-      stmt.destroySync();
-    }
-  }
-
-  /**
-   * Specialized finder backing `analysis/impact.ts:131-135` —
-   * `WHERE entry_point_id = ?`. Returns every {@link GraphNode} whose
-   * `entry_point_id` column matches the supplied id, with `id ASC`
-   * ordering matching the rest of the finder family.
-   */
-  async listNodesByEntryPoint(entryPointId: string): Promise<readonly GraphNode[]> {
-    const c = this.requireConn();
-    const columnList = NODE_COLUMNS.join(", ");
-    const stmt = await c.prepare(
-      `SELECT ${columnList} FROM nodes WHERE entry_point_id = ? ORDER BY id ASC`,
-    );
-    try {
-      stmt.bindVarchar(1, entryPointId);
-      const reader = await stmt.runAndReadAll();
-      const raw = normalizeRows(reader.getRowObjects());
-      const out: GraphNode[] = [];
-      for (const row of raw) {
-        const node = rowToGraphNode(row);
-        if (node) out.push(node);
-      }
-      return [...out].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
-    } finally {
-      stmt.destroySync();
-    }
-  }
-
-  /**
-   * Specialized finder backing `analysis/rename.ts:51,59` —
-   * `WHERE name = ?` with optional `kinds` / `filePath` narrowing.
-   * Returns rehydrated {@link GraphNode}s (full column set) so the
-   * caller has access to start/end lines and other wide-column fields
-   * that rename.ts needs to populate {@link SymbolLocation}.
-   */
-  async listNodesByName(
-    name: string,
-    opts: ListNodesByNameOptions = {},
-  ): Promise<readonly GraphNode[]> {
-    const c = this.requireConn();
-    const kinds = opts.kinds;
-    if (kinds !== undefined && kinds.length === 0) return [];
-    const limit = clampNonNegativeInt(opts.limit);
-    const columnList = NODE_COLUMNS.join(", ");
-    const wheres: string[] = ["name = ?"];
-    const binds: SqlParam[] = [name];
-    if (kinds && kinds.length > 0) {
-      wheres.push(`kind IN (${kinds.map(() => "?").join(", ")})`);
-      for (const k of kinds) binds.push(k);
-    }
-    if (opts.filePath !== undefined) {
-      wheres.push("file_path = ?");
-      binds.push(opts.filePath);
-    }
-    const limitClause = limit !== undefined ? "LIMIT ?" : "";
-    const sql = (
-      `SELECT ${columnList} FROM nodes WHERE ${wheres.join(" AND ")} ` +
-      `ORDER BY id ASC ${limitClause}`
-    ).trim();
-    const stmt = await c.prepare(sql);
-    try {
-      let idx = 1;
-      for (const b of binds) bindParam(stmt, idx++, b);
-      if (limit !== undefined) stmt.bindInteger(idx++, limit);
-      const reader = await stmt.runAndReadAll();
-      const raw = normalizeRows(reader.getRowObjects());
-      const out: GraphNode[] = [];
-      for (const row of raw) {
-        const node = rowToGraphNode(row);
-        if (node) out.push(node);
-      }
-      return [...out].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
-    } finally {
-      stmt.destroySync();
-    }
-  }
-
-  /**
-   * Counts grouped by kind. When `kinds` is supplied, missing kinds are
-   * still present in the result with count `0` — keeps the caller from
-   * having to special-case "kind not present in graph".
-   */
-  async countNodesByKind(kinds?: readonly NodeKind[]): Promise<Map<NodeKind, number>> {
-    const c = this.requireConn();
-    const out = new Map<NodeKind, number>();
-    if (kinds !== undefined && kinds.length === 0) return out;
-    let sql = "SELECT kind, COUNT(*) AS n FROM nodes";
-    const binds: SqlParam[] = [];
-    if (kinds && kinds.length > 0) {
-      const ph = kinds.map(() => "?").join(", ");
-      sql += ` WHERE kind IN (${ph})`;
-      for (const k of kinds) binds.push(k);
-    }
-    sql += " GROUP BY kind ORDER BY kind ASC";
-    const stmt = await c.prepare(sql);
-    try {
-      let idx = 1;
-      for (const b of binds) bindParam(stmt, idx++, b);
-      const reader = await stmt.runAndReadAll();
-      const rows = reader.getRowObjects();
-      for (const r of rows) {
-        const row = r as Record<string, unknown>;
-        const kindVal = row["kind"];
-        const n = row["n"];
-        if (typeof kindVal === "string") {
-          const num = typeof n === "bigint" ? Number(n) : Number(n ?? 0);
-          out.set(kindVal as NodeKind, num);
-        }
-      }
-      // Backfill zeros for kinds the caller asked about but which had no rows.
-      if (kinds) {
-        for (const k of kinds) {
-          if (!out.has(k)) out.set(k, 0);
-        }
-      }
-      return out;
-    } finally {
-      stmt.destroySync();
-    }
-  }
-
-  /** Counts grouped by edge type. Symmetric to {@link countNodesByKind}. */
-  async countEdgesByType(types?: readonly RelationType[]): Promise<Map<RelationType, number>> {
-    const c = this.requireConn();
-    const out = new Map<RelationType, number>();
-    if (types !== undefined && types.length === 0) return out;
-    let sql = "SELECT type, COUNT(*) AS n FROM relations";
-    const binds: SqlParam[] = [];
-    if (types && types.length > 0) {
-      const ph = types.map(() => "?").join(", ");
-      sql += ` WHERE type IN (${ph})`;
-      for (const t of types) binds.push(t);
-    }
-    sql += " GROUP BY type ORDER BY type ASC";
-    const stmt = await c.prepare(sql);
-    try {
-      let idx = 1;
-      for (const b of binds) bindParam(stmt, idx++, b);
-      const reader = await stmt.runAndReadAll();
-      const rows = reader.getRowObjects();
-      for (const r of rows) {
-        const row = r as Record<string, unknown>;
-        const typeVal = row["type"];
-        const n = row["n"];
-        if (typeof typeVal === "string") {
-          const num = typeof n === "bigint" ? Number(n) : Number(n ?? 0);
-          out.set(typeVal as RelationType, num);
-        }
-      }
-      if (types) {
-        for (const t of types) {
-          if (!out.has(t)) out.set(t, 0);
-        }
-      }
-      return out;
-    } finally {
-      stmt.destroySync();
-    }
-  }
-
-  /**
-   * Stream every embedding row in deterministic order. Implemented as an
-   * `async function*` so the caller can `for await` over the stream
-   * without materializing the full table — backs `pack/embeddings-sidecar`
-   * Parquet writer.
-   *
-   * Order: `(node_id ASC, granularity ASC, chunk_index ASC)`. Optional
-   * `kindFilter` joins through the `nodes` table on `embeddings.node_id =
-   * nodes.id` and narrows by kind. Empty `kindFilter` yields zero rows.
-   */
-  async *listEmbeddings(opts: ListEmbeddingsOptions = {}): AsyncIterable<EmbeddingRow> {
-    const c = this.requireConn();
-    const kinds = opts.kindFilter;
-    if (kinds !== undefined && kinds.length === 0) return;
-    const limit = clampNonNegativeInt(opts.limit);
-
-    const baseSelect =
-      "SELECT e.node_id, e.granularity, e.chunk_index, e.start_line, e.end_line, e.vector, e.content_hash";
-    const fromClause =
-      kinds && kinds.length > 0
-        ? "FROM embeddings e JOIN nodes n ON n.id = e.node_id"
-        : "FROM embeddings e";
-    const wheres: string[] = [];
-    const binds: SqlParam[] = [];
-    if (kinds && kinds.length > 0) {
-      const ph = kinds.map(() => "?").join(", ");
-      wheres.push(`n.kind IN (${ph})`);
-      for (const k of kinds) binds.push(k);
-    }
-    const whereClause = wheres.length > 0 ? `WHERE ${wheres.join(" AND ")}` : "";
-    const limitClause = limit !== undefined ? "LIMIT ?" : "";
-    const sql = (
-      `${baseSelect} ${fromClause} ${whereClause} ` +
-      `ORDER BY e.node_id ASC, e.granularity ASC, e.chunk_index ASC ${limitClause}`
-    ).trim();
-
-    const stmt = await c.prepare(sql);
-    try {
-      let idx = 1;
-      for (const b of binds) bindParam(stmt, idx++, b);
-      if (limit !== undefined) stmt.bindInteger(idx++, limit);
-      const reader = await stmt.runAndReadAll();
-      const raw = normalizeRows(reader.getRowObjects());
-      for (const r of raw) {
-        const row = r as Record<string, unknown>;
-        const vec = row["vector"];
-        let vector: Float32Array;
-        if (vec instanceof Float32Array) vector = vec;
-        else if (Array.isArray(vec)) vector = Float32Array.from(vec.map((v) => Number(v)));
-        else continue;
-        const nodeId = String(row["node_id"]);
-        const granularityRaw = String(row["granularity"]);
-        const granularity =
-          granularityRaw === "file" || granularityRaw === "community" ? granularityRaw : "symbol";
-        const chunkVal = row["chunk_index"];
-        const chunkIndex = typeof chunkVal === "bigint" ? Number(chunkVal) : Number(chunkVal ?? 0);
-        const startVal = row["start_line"];
-        const endVal = row["end_line"];
-        const baseRow: EmbeddingRow = {
-          nodeId,
-          granularity,
-          chunkIndex,
-          ...(startVal !== null && startVal !== undefined
-            ? { startLine: typeof startVal === "bigint" ? Number(startVal) : Number(startVal) }
-            : {}),
-          ...(endVal !== null && endVal !== undefined
-            ? { endLine: typeof endVal === "bigint" ? Number(endVal) : Number(endVal) }
-            : {}),
-          vector,
-          contentHash: String(row["content_hash"] ?? ""),
-        };
-        yield baseRow;
-      }
-    } finally {
-      stmt.destroySync();
-    }
-  }
-
-  /**
-   * Traverse ancestors of `fromId` along the supplied edge types up to
-   * `maxDepth`. Replaces the `WITH RECURSIVE` patterns in
-   * `analysis/impact.ts` and `mcp/tools/query.ts`.
-   */
-  async traverseAncestors(opts: AncestorTraversalOptions): Promise<readonly TraverseResult[]> {
-    return this.traverseDirectional(opts, "up");
-  }
-
-  /** Symmetric of {@link traverseAncestors} — walks descendants. */
-  async traverseDescendants(opts: DescendantTraversalOptions): Promise<readonly TraverseResult[]> {
-    return this.traverseDirectional(opts, "down");
-  }
-
-  /**
-   * Producer-consumer edges across repos. Implements the FETCHES + Route
-   * + Repo join in one statement. Determinism: ORDER BY
-   * `(consumer_repo_uri, producer_repo_uri, http_method, http_path)`.
-   *
-   * Repo membership is resolved by walking the `Repo` row whose `id` is
-   * the prefix of the consumer/producer node ids. The current ingestion
-   * stamps `repo_uri` directly on every node via the persisted Repo
-   * column — we read it inline rather than re-traversing the graph.
-   */
-  async listConsumerProducerEdges(
-    opts: { readonly repoUris?: readonly string[] } = {},
-  ): Promise<readonly ConsumerProducerEdge[]> {
-    const c = this.requireConn();
-    // FETCHES edges connect any consumer node (Function/Method/etc.) to a
-    // Route node owned by the producer. We join Route metadata directly,
-    // and pull the Repo `repo_uri` for both endpoints by joining a
-    // narrowed `repos` view to the relations table.
-    const wheres: string[] = ["r.type = 'FETCHES'"];
-    const binds: SqlParam[] = [];
-    if (opts.repoUris && opts.repoUris.length > 0) {
-      const ph = opts.repoUris.map(() => "?").join(", ");
-      wheres.push(`(consumer.repo_uri IN (${ph}) OR producer.repo_uri IN (${ph}))`);
-      for (const u of opts.repoUris) binds.push(u);
-      for (const u of opts.repoUris) binds.push(u);
-    }
-    const sql = `
-      SELECT
-        r.from_id      AS consumer_node_id,
-        consumer.repo_uri AS consumer_repo_uri,
-        r.to_id        AS producer_node_id,
-        producer.repo_uri AS producer_repo_uri,
-        producer.http_method AS http_method,
-        producer.http_path   AS http_path
-      FROM relations r
-      JOIN nodes consumer ON consumer.id = r.from_id
-      JOIN nodes producer ON producer.id = r.to_id
-      WHERE ${wheres.join(" AND ")} AND producer.kind = 'Operation'
-      ORDER BY consumer_repo_uri ASC, producer_repo_uri ASC,
-               http_method ASC, http_path ASC, r.id ASC`.trim();
-    const stmt = await c.prepare(sql);
-    try {
-      let idx = 1;
-      for (const b of binds) bindParam(stmt, idx++, b);
-      const reader = await stmt.runAndReadAll();
-      const rows = reader.getRowObjects();
-      const out: ConsumerProducerEdge[] = [];
-      for (const r of rows) {
-        const row = r as Record<string, unknown>;
-        out.push({
-          consumerNodeId: String(row["consumer_node_id"] ?? ""),
-          consumerRepoUri: String(row["consumer_repo_uri"] ?? ""),
-          producerNodeId: String(row["producer_node_id"] ?? ""),
-          producerRepoUri: String(row["producer_repo_uri"] ?? ""),
-          httpMethod: String(row["http_method"] ?? ""),
-          httpPath: String(row["http_path"] ?? ""),
-        });
-      }
-      return out;
-    } finally {
-      stmt.destroySync();
-    }
-  }
-
-  /**
-   * Shared `listEdges` body — used by {@link listEdges} and
-   * {@link listEdgesByType}. Determinism: ORDER BY `(from_id, to_id,
-   * type)` then a JS-side stable tiebreak on `id` so two adapters agree
-   * byte-for-byte even when the engine collation differs.
-   */
-  private async listEdgesInternal(
-    c: DuckDBConnection,
-    opts: ListEdgesOptions,
-  ): Promise<readonly CodeRelation[]> {
-    const wheres: string[] = [];
-    const binds: SqlParam[] = [];
-    if (opts.types && opts.types.length > 0) {
-      const ph = opts.types.map(() => "?").join(", ");
-      wheres.push(`type IN (${ph})`);
-      for (const t of opts.types) binds.push(t);
-    }
-    if (opts.fromIds && opts.fromIds.length > 0) {
-      const ph = opts.fromIds.map(() => "?").join(", ");
-      wheres.push(`from_id IN (${ph})`);
-      for (const f of opts.fromIds) binds.push(f);
-    }
-    if (opts.toIds && opts.toIds.length > 0) {
-      const ph = opts.toIds.map(() => "?").join(", ");
-      wheres.push(`to_id IN (${ph})`);
-      for (const t of opts.toIds) binds.push(t);
-    }
-    if (opts.minConfidence !== undefined) {
-      wheres.push("confidence >= ?");
-      binds.push(opts.minConfidence);
-    }
-    const limit = clampNonNegativeInt(opts.limit);
-    const offset = clampNonNegativeInt(opts.offset);
-    const whereClause = wheres.length > 0 ? `WHERE ${wheres.join(" AND ")}` : "";
-    const limitClause = limit !== undefined ? "LIMIT ?" : "";
-    const offsetClause = offset !== undefined ? "OFFSET ?" : "";
-    const sql = (
-      `SELECT id, from_id, to_id, type, confidence, reason, step ` +
-      `FROM relations ${whereClause} ` +
-      `ORDER BY from_id ASC, to_id ASC, type ASC, id ASC ${limitClause} ${offsetClause}`
-    ).trim();
-    const stmt = await c.prepare(sql);
-    try {
-      let idx = 1;
-      for (const b of binds) bindParam(stmt, idx++, b);
-      if (limit !== undefined) stmt.bindInteger(idx++, limit);
-      if (offset !== undefined) stmt.bindInteger(idx++, offset);
-      const reader = await stmt.runAndReadAll();
-      const rows = reader.getRowObjects();
-      const out: CodeRelation[] = [];
-      for (const r of rows) {
-        const row = r as Record<string, unknown>;
-        const stepVal = row["step"];
-        // Step-zero sentinel: DuckDB stores `INT NOT NULL DEFAULT 0`
-        // for absent step values; collapse 0 to "field absent" so the
-        // wire shape matches the source `CodeRelation`.
-        const step =
-          stepVal === null || stepVal === undefined || Number(stepVal) === 0
-            ? undefined
-            : Number(stepVal);
-        const reasonVal = row["reason"];
-        const reason =
-          typeof reasonVal === "string" && reasonVal.length > 0 ? reasonVal : undefined;
-        out.push({
-          id: String(row["id"] ?? "") as CodeRelation["id"],
-          from: String(row["from_id"] ?? "") as CodeRelation["from"],
-          to: String(row["to_id"] ?? "") as CodeRelation["to"],
-          type: String(row["type"] ?? "") as RelationType,
-          confidence: Number(row["confidence"] ?? 0),
-          ...(reason !== undefined ? { reason } : {}),
-          ...(step !== undefined ? { step } : {}),
-        });
-      }
-      return out;
-    } finally {
-      stmt.destroySync();
-    }
-  }
-
-  /**
-   * Shared body for {@link traverseAncestors} / {@link traverseDescendants}.
-   * Reuses the existing recursive-CTE machinery via a thin wrapper —
-   * direction is "up" for ancestors and "down" for descendants.
-   */
-  private async traverseDirectional(
-    opts: AncestorTraversalOptions | DescendantTraversalOptions,
-    direction: "up" | "down",
-  ): Promise<readonly TraverseResult[]> {
-    if (opts.edgeTypes.length === 0) return [];
-    const traverseQuery: TraverseQuery = {
-      startId: opts.fromId,
-      relationTypes: opts.edgeTypes,
-      direction,
-      maxDepth: opts.maxDepth,
-      ...(opts.minConfidence !== undefined ? { minConfidence: opts.minConfidence } : {}),
-    };
-    return this.traverse(traverseQuery);
-  }
-
-  async search(q: SearchQuery): Promise<readonly SearchResult[]> {
-    const c = this.requireConn();
-    const limit = q.limit ?? 50;
-    const kindFilter = q.kinds && q.kinds.length > 0 ? q.kinds : undefined;
-    const kindPlaceholders = kindFilter ? kindFilter.map(() => "?").join(",") : "";
-    const kindClause = kindFilter ? ` AND kind IN (${kindPlaceholders})` : "";
-
-    // Materialize the BM25 score + primary key in a CTE, then sort. A plain
-    // ORDER BY on a subquery with `match_bm25` has been observed to return
-    // non-deterministic orderings when many rows tie on score — apparently
-    // DuckDB's planner elides the sort when it thinks it can stream results.
-    // Forcing the score into a CTE and applying ROUND to the score drops
-    // floating-point jitter that can also confuse tie-breakers.
-    const sql = `WITH scored AS (
-        SELECT id, name, kind, file_path,
-               ROUND(fts_main_nodes.match_bm25(id, ?), 9) AS score
-        FROM nodes
-      )
-      SELECT id, name, kind, file_path, score
-      FROM scored
-      WHERE score IS NOT NULL${kindClause}
-      ORDER BY score DESC, id ASC, file_path ASC, name ASC
-      LIMIT ?`;
-    const stmt = await c.prepare(sql);
-    try {
-      let idx = 1;
-      stmt.bindVarchar(idx++, q.text);
-      if (kindFilter) {
-        for (const k of kindFilter) stmt.bindVarchar(idx++, k);
-      }
-      stmt.bindInteger(idx++, limit);
-      const reader = await stmt.runAndReadAll();
-      const rows = reader.getRowObjects();
-      const results: SearchResult[] = [];
-      for (const r of rows) {
-        const row = r as Record<string, unknown>;
-        results.push({
-          nodeId: String(row["id"]),
-          name: String(row["name"] ?? ""),
-          kind: String(row["kind"] ?? ""),
-          filePath: String(row["file_path"] ?? ""),
-          score: Number(row["score"] ?? 0),
-        });
-      }
-      return results;
-    } finally {
-      stmt.destroySync();
-    }
-  }
-
-  async vectorSearch(q: VectorQuery): Promise<readonly VectorResult[]> {
-    if (this.vectorExtension === "none") {
-      throw new Error(
-        this.extensionWarning ?? "Vector search unavailable: no HNSW extension loaded",
-      );
-    }
-    if (q.vector.length !== this.embeddingDim) {
-      throw new Error(
-        `Vector dimension mismatch: got ${q.vector.length}, expected ${this.embeddingDim}`,
-      );
-    }
-    const c = this.requireConn();
-    const limit = q.limit ?? 10;
-
-    // Normalize the granularity filter (optional) into a list of tier names
-    // so we can push a single IN-predicate through hnsw_acorn — the extension
-    // handles the ACORN-1 push-down for us.
-    const granularities: readonly string[] | undefined =
-      q.granularity === undefined
-        ? undefined
-        : Array.isArray(q.granularity)
-          ? (q.granularity as readonly string[])
-          : [q.granularity as string];
-
-    const extraWhere: string[] = [];
-    const extraParams: SqlParam[] = [];
-    if (granularities !== undefined && granularities.length > 0) {
-      const ph = granularities.map(() => "?").join(",");
-      extraWhere.push(`e.granularity IN (${ph})`);
-      for (const g of granularities) extraParams.push(g);
-    }
-
-    // Filter-first subquery pattern: pre-filter embeddings by the optional
-    // whereClause (joined to nodes as `n`) and only then compute distance +
-    // ORDER BY. This sidesteps DuckDB planner quirks where an HNSW index scan
-    // might drop the WHERE filter entirely on small datasets.
-    const userWhere = q.whereClause;
-    const needsJoin = userWhere !== undefined && userWhere.length > 0;
-    const whereParts: string[] = [];
-    if (userWhere !== undefined && userWhere.length > 0) whereParts.push(`(${userWhere})`);
-    whereParts.push(...extraWhere);
-    const wherePredicate = whereParts.length > 0 ? `WHERE ${whereParts.join(" AND ")}` : "";
-    const filterSql = needsJoin
-      ? `SELECT e.node_id, e.vector
-         FROM embeddings e JOIN nodes n ON n.id = e.node_id
-         ${wherePredicate}`
-      : `SELECT e.node_id, e.vector
-         FROM embeddings e
-         ${wherePredicate}`;
-    const sql = `WITH filtered AS (${filterSql})
-      SELECT node_id, array_distance(vector, ?) AS distance
-      FROM filtered
-      ORDER BY distance
-      LIMIT ?`;
-
-    const stmt = await c.prepare(sql);
-    try {
-      // Positional binds: whereClause params first, then granularity params,
-      // then vector, then limit.
-      let idx = 1;
-      if (q.params) {
-        for (const p of q.params) {
-          bindParam(stmt, idx++, p);
-        }
-      }
-      for (const p of extraParams) {
-        bindParam(stmt, idx++, p);
-      }
-      stmt.bindArray(idx++, arrayValue(Array.from(q.vector)), ARRAY(FLOAT, this.embeddingDim));
-      stmt.bindInteger(idx++, limit);
-      const reader = await stmt.runAndReadAll();
-      const rows = reader.getRowObjects();
-      const out: VectorResult[] = [];
-      for (const r of rows) {
-        const row = r as Record<string, unknown>;
-        out.push({
-          nodeId: String(row["node_id"]),
-          distance: Number(row["distance"] ?? 0),
-        });
-      }
-      return out;
-    } finally {
-      stmt.destroySync();
-    }
-  }
-
-  async traverse(q: TraverseQuery): Promise<readonly TraverseResult[]> {
-    const c = this.requireConn();
-    const maxDepth = Math.max(0, q.maxDepth);
-    const minConfidence = q.minConfidence ?? 0;
-    const relTypes: readonly string[] =
-      q.relationTypes && q.relationTypes.length > 0 ? q.relationTypes : ALL_RELATION_TYPES;
-    const typePlaceholders = relTypes.map(() => "?").join(",");
-
-    // Build direction-appropriate recursive CTE. USING KEY collapses repeated
-    // visits to the same node_id, giving us bounded memory on cyclic graphs.
-    // DuckDB recursive CTEs only allow ONE recursive term after the anchor, so
-    // "both" uses a single body that picks the neighbor via CASE at each step
-    // rather than UNION-ing two recursive references to `walk`.
-    const downBody = `
-      SELECT r.to_id AS node_id, w.depth + 1 AS depth,
-             list_append(w.path, r.to_id) AS path
-      FROM walk w JOIN relations r ON r.from_id = w.node_id
-      WHERE w.depth < ? AND r.confidence >= ? AND r.type IN (${typePlaceholders})`;
-    const upBody = `
-      SELECT r.from_id AS node_id, w.depth + 1 AS depth,
-             list_append(w.path, r.from_id) AS path
-      FROM walk w JOIN relations r ON r.to_id = w.node_id
-      WHERE w.depth < ? AND r.confidence >= ? AND r.type IN (${typePlaceholders})`;
-    const bothBody = `
-      SELECT CASE WHEN r.from_id = w.node_id THEN r.to_id ELSE r.from_id END AS node_id,
-             w.depth + 1 AS depth,
-             list_append(
-               w.path,
-               CASE WHEN r.from_id = w.node_id THEN r.to_id ELSE r.from_id END
-             ) AS path
-      FROM walk w JOIN relations r
-        ON (r.from_id = w.node_id OR r.to_id = w.node_id)
-      WHERE w.depth < ? AND r.confidence >= ? AND r.type IN (${typePlaceholders})`;
-
-    let recursiveBody: string;
-    if (q.direction === "down") recursiveBody = downBody;
-    else if (q.direction === "up") recursiveBody = upBody;
-    else recursiveBody = bothBody;
-
-    // In the "both" direction, a 2-hop cycle (e.g., B -> A -> B) can reach the
-    // start node at depth 2 because the recursive body walks edges in either
-    // direction. Filter it out at the final SELECT so callers never see the
-    // start node in their results (matching the "up"/"down" behavior where the
-    // start is already unreachable via the single-direction edge set).
-    const sql = `WITH RECURSIVE walk(node_id, depth, path) USING KEY (node_id) AS (
-      SELECT CAST(? AS TEXT) AS node_id, 0 AS depth, [CAST(? AS TEXT)] AS path
-      UNION ALL${recursiveBody}
-    )
-    SELECT node_id, depth, path FROM walk
-    WHERE depth > 0 AND node_id <> CAST(? AS TEXT)
-    ORDER BY depth, node_id`;
-
-    const stmt = await c.prepare(sql);
-    try {
-      let idx = 1;
-      stmt.bindVarchar(idx++, q.startId);
-      stmt.bindVarchar(idx++, q.startId);
-
-      // Every branch has exactly one recursive body, so bind
-      // (maxDepth, minConfidence, *types) exactly once.
-      stmt.bindInteger(idx++, maxDepth);
-      stmt.bindDouble(idx++, minConfidence);
-      for (const t of relTypes) stmt.bindVarchar(idx++, t);
-
-      // Bound for the final WHERE node_id <> ? filter.
-      stmt.bindVarchar(idx++, q.startId);
-      const reader = await stmt.runAndReadAll();
-      const rows = reader.getRowObjects();
-      const out: TraverseResult[] = [];
-      for (const r of rows) {
-        const row = r as Record<string, unknown>;
-        const pathVal = row["path"];
-        const path: string[] = Array.isArray(pathVal) ? pathVal.map((v) => String(v)) : [];
-        out.push({
-          nodeId: String(row["node_id"]),
-          depth: Number(row["depth"] ?? 0),
-          path,
-        });
-      }
-      return out;
-    } finally {
-      stmt.destroySync();
-    }
-  }
-
-  // --------------------------------------------------------------------------
-  // Meta
-  // --------------------------------------------------------------------------
-
-  async getMeta(): Promise<StoreMeta | undefined> {
-    const c = this.requireConn();
-    const reader = await c.runAndReadAll(
-      `SELECT schema_version, last_commit, indexed_at, node_count, edge_count,
-              stats_json, cache_hit_ratio, cache_size_bytes, last_compaction,
-              embedder_model_id
-       FROM store_meta WHERE id = 1`,
-    );
-    const rows = reader.getRowObjects();
-    const first = rows[0];
-    if (!first) return undefined;
-    const row = first as Record<string, unknown>;
-    const stats = row["stats_json"]
-      ? (JSON.parse(String(row["stats_json"])) as Record<string, number>)
-      : undefined;
-    const lastCommit = row["last_commit"];
-    const cacheHitRatio = row["cache_hit_ratio"];
-    const cacheSizeBytes = row["cache_size_bytes"];
-    const lastCompaction = row["last_compaction"];
-    const embedderModelId = row["embedder_model_id"];
-    return {
-      schemaVersion: String(row["schema_version"]),
-      ...(lastCommit !== null && lastCommit !== undefined
-        ? { lastCommit: String(lastCommit) }
-        : {}),
-      indexedAt: String(row["indexed_at"]),
-      nodeCount: Number(row["node_count"] ?? 0),
-      edgeCount: Number(row["edge_count"] ?? 0),
-      ...(stats ? { stats } : {}),
-      ...(cacheHitRatio !== null && cacheHitRatio !== undefined
-        ? { cacheHitRatio: Number(cacheHitRatio) }
-        : {}),
-      ...(cacheSizeBytes !== null && cacheSizeBytes !== undefined
-        ? { cacheSizeBytes: Number(cacheSizeBytes) }
-        : {}),
-      ...(lastCompaction !== null && lastCompaction !== undefined
-        ? { lastCompaction: String(lastCompaction) }
-        : {}),
-      ...(embedderModelId !== null && embedderModelId !== undefined
-        ? { embedderModelId: String(embedderModelId) }
-        : {}),
-    };
-  }
-
-  async setMeta(meta: StoreMeta): Promise<void> {
-    const c = this.requireConn();
-    const statsJson = meta.stats ? canonicalJson(meta.stats) : null;
-    // Single-row meta: DELETE+INSERT keeps things predictable without relying
-    // on DuckDB upsert semantics.
-    await c.run("DELETE FROM store_meta WHERE id = 1");
-    const stmt = await c.prepare(
-      `INSERT INTO store_meta (
-        id, schema_version, last_commit, indexed_at, node_count, edge_count,
-        stats_json, cache_hit_ratio, cache_size_bytes, last_compaction,
-        embedder_model_id
-      ) VALUES (1, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    );
-    try {
-      bindParam(stmt, 1, meta.schemaVersion);
-      bindParam(stmt, 2, meta.lastCommit ?? null);
-      bindParam(stmt, 3, meta.indexedAt);
-      bindParam(stmt, 4, meta.nodeCount);
-      bindParam(stmt, 5, meta.edgeCount);
-      bindParam(stmt, 6, statsJson);
-      bindParam(stmt, 7, meta.cacheHitRatio ?? null);
-      bindParam(stmt, 8, meta.cacheSizeBytes ?? null);
-      bindParam(stmt, 9, meta.lastCompaction ?? null);
-      bindParam(stmt, 10, meta.embedderModelId ?? null);
-      await stmt.run();
-    } finally {
-      stmt.destroySync();
-    }
-  }
-
-  async healthCheck(): Promise<{ ok: boolean; message?: string }> {
-    try {
-      const c = this.requireConn();
-      const reader = await c.runAndReadAll("SELECT 1 AS one");
-      const rows = reader.getRowObjects();
-      const first = rows[0] as { one?: unknown } | undefined;
-      const ok = !!first && Number(first.one) === 1;
-      return ok ? { ok: true } : { ok: false, message: "SELECT 1 returned unexpected shape" };
-    } catch (err) {
-      return { ok: false, message: (err as Error).message };
-    }
-  }
-
-  // --------------------------------------------------------------------------
-  // Internal helpers
-  // --------------------------------------------------------------------------
-
-  private requireConn(): DuckDBConnection {
-    if (!this.conn) {
-      throw new Error("DuckDbStore is not open — call open() first");
-    }
-    return this.conn;
-  }
-
-  /**
-   * Interrupt the current statement if it exceeds the timeout. DuckDB has no
-   * SQL-level statement timeout, so we schedule a JS timer that calls
-   * `connection.interrupt()` and let the prepared statement throw.
+   * Interrupt the current statement if it exceeds the timeout. DuckDB has no
+   * SQL-level statement timeout, so we schedule a JS timer that calls
+   * `connection.interrupt()` and let the prepared statement throw.
    */
   private async withTimeout<T>(ms: number, fn: () => Promise<T>): Promise<T> {
     if (ms <= 0) return fn();
@@ -2043,51 +509,11 @@ export class DuckDbStore implements IGraphStore, ITemporalStore {
 // Free helpers
 // ----------------------------------------------------------------------------
 
-/**
- * Convert a GraphNode into the positional row ordering expected by the
- * `nodes` table DDL. Each slot is either a typed scalar, an array (for
- * `TEXT[]` columns), or `null`.
- *
- * The body of this function is now a thin projection from
- * {@link nodeToColumns} (in `column-encode.ts`) into the canonical
- * `NODE_COLUMNS` order — keeping the local name `nodeToRow` so the call
- * sites in `insertNodes` continue to read naturally and so unrelated
- * adapter-internal references (e.g. JSDoc in `rowToGraphNode`) stay valid.
- *
- * Field/column aliasing handled inside `nodeToColumns`:
- *   - `OperationNode.method` → `http_method` column (not `method`, which is
- *     reserved for RouteNode).
- *   - `OperationNode.path`   → `http_path`   column.
- *   The Operation write-through still preserves read-back determinism
- *   because the round-trip helper maps `http_method`/`http_path` back to
- *   `method`/`path` when `kind === "Operation"`.
- */
-function nodeToRow(node: GraphNode): readonly (SqlParam | readonly string[])[] {
-  const cols = nodeToColumns(node);
-  return NODE_COLUMNS.map((key) => cols[key] as SqlParam | readonly string[] | null);
-}
-
-function bindParam(
-  stmt: DuckDBPreparedStatement,
-  index: number,
-  value: SqlParam | readonly string[] | null,
-): void {
+function bindParam(stmt: DuckDBPreparedStatement, index: number, value: SqlParam | null): void {
   if (value === null || value === undefined) {
     stmt.bindNull(index);
     return;
   }
-  if (Array.isArray(value)) {
-    // DuckDB TEXT[] → bind as a list of varchar values. Use bindList (VARIABLE
-    // length), not bindArray (FIXED length) — `TEXT[]` in the DDL is a LIST.
-    //
-    // Pass the explicit `LIST(VARCHAR)` type so an empty array (`[]`,
-    // written intentionally to preserve the `keywords: []` vs absent
-    // distinction) binds as `LIST<VARCHAR>` rather than `LIST<ANY>`.
-    // Without the type hint DuckDB rejects empty lists with
-    // "Cannot create lists with item type of ANY".
-    stmt.bindList(index, listValue([...(value as readonly string[])]), LIST(VARCHAR));
-    return;
-  }
   switch (typeof value) {
     case "boolean":
       stmt.bindBoolean(index, value);
@@ -2129,295 +555,18 @@ function normalizeRows(rows: readonly unknown[]): readonly Record<string, unknow
   return out;
 }
 
-/**
- * Clamp a number to a non-negative integer, returning `undefined` for
- * unset / non-finite / negative inputs. Used by listNodes() to gate the
- * optional LIMIT / OFFSET parameters — callers that pass `0` get a real
- * `0` (semantically valid) while `undefined` / `-1` / `NaN` skip the
- * clause entirely.
- */
-function clampNonNegativeInt(v: number | undefined): number | undefined {
-  if (v === undefined || v === null) return undefined;
-  if (typeof v !== "number" || !Number.isFinite(v)) return undefined;
-  if (v < 0) return undefined;
-  return Math.floor(v);
-}
-
-/**
- * Rehydrate a row from the polymorphic `nodes` table into a typed
- * {@link GraphNode}. The inverse of {@link nodeToRow}: every column it
- * writes is read back here, and every kind-specific field aliasing
- * (Operation `http_method`/`http_path` → `method`/`path`) is reversed.
- *
- * Returns `undefined` when the row is missing the load-bearing
- * primary-key columns (`id`, `kind`, `name`, `file_path`) so a corrupt
- * row never poisons the caller's array.
- *
- * Field-population strategy: every property on the result is set
- * conditionally — fields whose underlying column is NULL are LEFT OFF
- * the object so `Object.keys(result)` matches the original GraphNode
- * shape (modulo the documented round-trip subset). This keeps
- * `canonicalJson` / `graphHash` stable when callers serialise the
- * output.
- */
-function rowToGraphNode(row: Record<string, unknown>): GraphNode | undefined {
-  const id = row["id"];
-  const kindVal = row["kind"];
-  const name = row["name"];
-  const filePath = row["file_path"];
-  if (
-    typeof id !== "string" ||
-    typeof kindVal !== "string" ||
-    typeof name !== "string" ||
-    typeof filePath !== "string"
-  ) {
-    return undefined;
-  }
-  const isOperation = kindVal === "Operation";
-
-  const out: Record<string, unknown> = {
-    id,
-    kind: kindVal,
-    name,
-    filePath,
-  };
-
-  // Scalar columns — written as primitives by `nodeToRow`. Each branch
-  // skips when the column is NULL/undefined so the resulting object's
-  // key set mirrors the original GraphNode (e.g. a Function with no
-  // `signature` field comes back without a `signature` key, not with
-  // `signature: null`).
-  setStringField(out, "signature", row["signature"]);
-  setNumberField(out, "startLine", row["start_line"]);
-  setNumberField(out, "endLine", row["end_line"]);
-  setBooleanField(out, "isExported", row["is_exported"]);
-  setNumberField(out, "parameterCount", row["parameter_count"]);
-  setStringField(out, "returnType", row["return_type"]);
-  setStringField(out, "declaredType", row["declared_type"]);
-  setStringField(out, "owner", row["owner"]);
-  setStringField(out, "url", row["url"]);
-  // Route.method comes from the `method` column; Operation.method comes
-  // from the `http_method` column. Both write back to `node.method` on
-  // their respective kinds.
-  if (isOperation) {
-    setStringField(out, "method", row["http_method"]);
-    setStringField(out, "path", row["http_path"]);
-  } else {
-    setStringField(out, "method", row["method"]);
-  }
-  setStringField(out, "toolName", row["tool_name"]);
-  setStringField(out, "content", row["content"]);
-  setStringField(out, "contentHash", row["content_hash"]);
-  setStringField(out, "inferredLabel", row["inferred_label"]);
-  setNumberField(out, "symbolCount", row["symbol_count"]);
-  setNumberField(out, "cohesion", row["cohesion"]);
-  setStringArrayField(out, "keywords", row["keywords"]);
-  setStringField(out, "entryPointId", row["entry_point_id"]);
-  setNumberField(out, "stepCount", row["step_count"]);
-  setNumberField(out, "level", row["level"]);
-  setStringArrayField(out, "responseKeys", row["response_keys"]);
-  setStringField(out, "description", row["description"]);
-  // Finding (SARIF).
-  setStringField(out, "severity", row["severity"]);
-  setStringField(out, "ruleId", row["rule_id"]);
-  setStringField(out, "scannerId", row["scanner_id"]);
-  setStringField(out, "message", row["message"]);
-  setJsonObjectField(out, "propertiesBag", row["properties_bag"]);
-  // Dependency.
-  setStringField(out, "version", row["version"]);
-  setStringField(out, "license", row["license"]);
-  setStringField(out, "lockfileSource", row["lockfile_source"]);
-  setStringField(out, "ecosystem", row["ecosystem"]);
-  // Operation.summary / .operationId — these don't collide with anything else.
-  setStringField(out, "summary", row["summary"]);
-  setStringField(out, "operationId", row["operation_id"]);
-  // Contributor.
-  setStringField(out, "emailHash", row["email_hash"]);
-  setStringField(out, "emailPlain", row["email_plain"]);
-  // ProjectProfile (JSON-encoded array fields).
-  setJsonArrayField(out, "languages", row["languages_json"]);
-  // `frameworks_json` carries either the legacy flat-string-array shape
-  // or the v2 `{flat, detected}` envelope. Tease out both fields when the
-  // envelope is present so consumers that read either surface get the
-  // expected types.
-  applyFrameworksJsonReadback(out, row["frameworks_json"]);
-  setJsonArrayField(out, "iacTypes", row["iac_types_json"]);
-  setJsonArrayField(out, "apiContracts", row["api_contracts_json"]);
-  setJsonArrayField(out, "manifests", row["manifests_json"]);
-  setJsonArrayField(out, "srcDirs", row["src_dirs_json"]);
-  // File / Community ownership.
-  setStringField(out, "orphanGrade", row["orphan_grade"]);
-  setBooleanField(out, "isOrphan", row["is_orphan"]);
-  setNumberField(out, "truckFactor", row["truck_factor"]);
-  setNumberField(out, "ownershipDrift30d", row["ownership_drift_30d"]);
-  setNumberField(out, "ownershipDrift90d", row["ownership_drift_90d"]);
-  setNumberField(out, "ownershipDrift365d", row["ownership_drift_365d"]);
-  // v1.2 extensions.
-  setStringField(out, "deadness", denormalizeDeadness(row["deadness"]));
-  setNumberField(out, "coveragePercent", row["coverage_percent"]);
-  setStringField(out, "coveredLinesJson", row["covered_lines_json"]);
-  setNumberField(out, "cyclomaticComplexity", row["cyclomatic_complexity"]);
-  setNumberField(out, "nestingDepth", row["nesting_depth"]);
-  setNumberField(out, "nloc", row["nloc"]);
-  setNumberField(out, "halsteadVolume", row["halstead_volume"]);
-  setStringField(out, "inputSchemaJson", row["input_schema_json"]);
-  setStringField(out, "partialFingerprint", row["partial_fingerprint"]);
-  setStringField(out, "baselineState", row["baseline_state"]);
-  setStringField(out, "suppressedJson", row["suppressed_json"]);
-  // Repo. The interface marks `originUrl` / `defaultBranch` /
-  // `group` as `string | null` so the round-trip preserves an explicit
-  // null when the column is NULL. Other Repo fields are populated only
-  // when `kind === "Repo"`; for non-Repo rows the columns stay NULL and
-  // the field is left off entirely.
-  if (kindVal === "Repo") {
-    out["originUrl"] = readNullableString(row["origin_url"]);
-    setStringField(out, "repoUri", row["repo_uri"]);
-    out["defaultBranch"] = readNullableString(row["default_branch"]);
-    setStringField(out, "commitSha", row["commit_sha"]);
-    setStringField(out, "indexTime", row["index_time"]);
-    out["group"] = readNullableString(row["repo_group"]);
-    setStringField(out, "visibility", row["visibility"]);
-    setStringField(out, "indexer", row["indexer"]);
-    out["languageStats"] = readLanguageStats(row["language_stats_json"]);
-  }
-  return out as unknown as GraphNode;
-}
-
-function setStringField(out: Record<string, unknown>, key: string, v: unknown): void {
-  if (typeof v === "string" && v.length > 0) out[key] = v;
-}
-
-function setNumberField(out: Record<string, unknown>, key: string, v: unknown): void {
-  if (v === null || v === undefined) return;
-  if (typeof v === "number" && Number.isFinite(v)) {
-    out[key] = v;
-    return;
-  }
-  if (typeof v === "bigint") {
-    out[key] = Number(v);
-    return;
-  }
-  // DuckDB occasionally returns numeric-typed columns as strings when the
-  // underlying type is DECIMAL — coerce defensively. Only digits / dot /
-  // sign survive the parse.
-  if (typeof v === "string" && /^-?\d+(\.\d+)?$/.test(v)) {
-    const n = Number(v);
-    if (Number.isFinite(n)) out[key] = n;
-  }
-}
-
-function setBooleanField(out: Record<string, unknown>, key: string, v: unknown): void {
-  if (typeof v === "boolean") out[key] = v;
-}
-
-function setStringArrayField(out: Record<string, unknown>, key: string, v: unknown): void {
-  // Preserve `[]` distinct from absent. The DuckDB TEXT[] binder returns
-  // a 0-length JS array for an empty SQL array literal and `null` for SQL
-  // NULL. Re-attach the array verbatim so a node written as
-  // `{keywords: []}` round-trips with `keywords: []` (not coalesced away)
-  // — required for canonical-JSON / graphHash byte-identity.
-  if (!Array.isArray(v)) return;
-  const arr: string[] = [];
-  for (const item of v) {
-    if (typeof item === "string") arr.push(item);
-  }
-  out[key] = arr;
-}
-
-function setJsonArrayField(out: Record<string, unknown>, key: string, v: unknown): void {
-  if (typeof v !== "string" || v.length === 0) return;
-  try {
-    const parsed = JSON.parse(v);
-    if (Array.isArray(parsed)) out[key] = parsed;
-  } catch {
-    /* row stored a non-JSON string for this column — skip the field. */
-  }
-}
-
-function setJsonObjectField(out: Record<string, unknown>, key: string, v: unknown): void {
-  if (typeof v !== "string" || v.length === 0) return;
-  try {
-    const parsed = JSON.parse(v);
-    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
-      out[key] = parsed;
-    }
-  } catch {
-    /* skip */
-  }
-}
-
-/**
- * Read the polymorphic `frameworks_json` column. Two on-disk shapes:
- *   - Legacy v1.0: a flat `string[]`.
- *   - v2.0: `{ flat: string[], detected: FrameworkDetection[] }`.
- *
- * Both populate `frameworks` (the flat-string list); v2 additionally
- * populates `frameworksDetected`. Skipped silently when the column is
- * NULL or holds non-JSON.
- */
-function applyFrameworksJsonReadback(out: Record<string, unknown>, v: unknown): void {
-  if (typeof v !== "string" || v.length === 0) return;
-  try {
-    const parsed = JSON.parse(v);
-    if (Array.isArray(parsed)) {
-      out["frameworks"] = parsed;
-      return;
-    }
-    if (parsed && typeof parsed === "object") {
-      const env = parsed as { flat?: unknown; detected?: unknown };
-      if (Array.isArray(env.flat)) out["frameworks"] = env.flat;
-      if (Array.isArray(env.detected) && env.detected.length > 0) {
-        out["frameworksDetected"] = env.detected;
-      }
+function normalizeValue(v: unknown): unknown {
+  if (v === null || v === undefined) return v;
+  if (Array.isArray(v)) return v.map((x) => normalizeValue(x));
+  if (typeof v === "object") {
+    const obj = v as { items?: unknown };
+    if (Array.isArray(obj.items)) {
+      return obj.items.map((x) => normalizeValue(x));
     }
-  } catch {
-    /* skip on parse failure */
   }
-}
-
-/**
- * Reverse of `normalizeDeadness` in the writer. Stored as the underscored
- * form `unreachable_export`; expose the hyphenated `unreachable-export`
- * the dead-code phase emits. Pass through `live` / `dead` unchanged.
- */
-function denormalizeDeadness(v: unknown): unknown {
-  if (v === "unreachable_export") return "unreachable-export";
   return v;
 }
 
-/**
- * Resolve a Repo nullable-string column. The interface declares these as
- * `string | null` (not `string | undefined`), so missing columns must
- * round-trip as an explicit `null` rather than leaving the key off.
- */
-function readNullableString(v: unknown): string | null {
-  if (typeof v === "string" && v.length > 0) return v;
-  return null;
-}
-
-/**
- * Reconstruct `RepoNode.languageStats` from the canonical-JSON column.
- * Returns an empty object when the column is NULL / unparsable so the
- * field is always present (the interface requires it; node serialization
- * relies on `Object.keys(...)` to be deterministic).
- */
-function readLanguageStats(v: unknown): Readonly<Record<string, number>> {
-  if (typeof v !== "string" || v.length === 0) return {};
-  try {
-    const parsed = JSON.parse(v);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      const out: Record<string, number> = {};
-      for (const [k, val] of Object.entries(parsed as Record<string, unknown>)) {
-        if (typeof val === "number" && Number.isFinite(val)) out[k] = val;
-      }
-      return out;
-    }
-  } catch {
-    /* fallthrough */
-  }
-  return {};
-}
-
 /**
  * Convert a DuckDB row from the `cochanges` table back into a {@link CochangeRow}.
  * The timestamp column arrives as either a DuckDB value object carrying a
@@ -2454,10 +603,7 @@ function cochangeRowFromRecord(row: Record<string, unknown>): CochangeRow {
 
 /**
  * Convert a DuckDB row from the `symbol_summaries` table back into a
- * {@link SymbolSummaryRow}. Mirrors the timestamp-coercion pattern used by
- * {@link cochangeRowFromRecord} so `created_at` round-trips identically
- * whether the native bindings return a DuckDB value object or a plain
- * string.
+ * {@link SymbolSummaryRow}.
  */
 function summaryRowFromRecord(row: Record<string, unknown>): SymbolSummaryRow {
   const created = row["created_at"];
@@ -2490,18 +636,6 @@ function summaryRowFromRecord(row: Record<string, unknown>): SymbolSummaryRow {
   };
 }
 
-function normalizeValue(v: unknown): unknown {
-  if (v === null || v === undefined) return v;
-  if (Array.isArray(v)) return v.map((x) => normalizeValue(x));
-  if (typeof v === "object") {
-    const obj = v as { items?: unknown };
-    if (Array.isArray(obj.items)) {
-      return obj.items.map((x) => normalizeValue(x));
-    }
-  }
-  return v;
-}
-
 /**
  * Conservative absolute-path validator used by `exportEmbeddingsParquet`
  * to inline a destination path into a `COPY ... TO '<path>' ...` SQL
@@ -2518,14 +652,8 @@ function isSafeAbsolutePath(p: string): boolean {
 
 /**
  * Classify a SPDX-ish license string into one of the five
- * {@link ListDependenciesOptions.licenseTier} buckets. Used by
- * {@link DuckDbStore.listDependencies} (and the symmetric graph-db
- * adapter helper) to satisfy the typed `licenseTier` filter without
- * the consumer pre-classifying every row.
- *
- * The match list mirrors the OCH `license_audit` rules — keep the two
- * surfaces in lockstep so a tier filter on `listDependencies` returns
- * the same set the audit reports for the same tier.
+ * license-tier buckets. Used by graph-side `listDependencies` finders;
+ * kept here as a free helper for cross-adapter symmetry.
  */
 export function classifyLicenseTier(
   license: string | undefined,
diff --git a/packages/storage/src/finders.test.ts b/packages/storage/src/finders.test.ts
deleted file mode 100644
index eb3b35c8..00000000
--- a/packages/storage/src/finders.test.ts
+++ /dev/null
@@ -1,952 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-//
-// Typed-finder tests for both adapters.
-//
-// Each finder is exercised against a small fixture loaded into a DuckDbStore.
-// Where the native graph-db binding is available, the same fixture is loaded
-// into a GraphDbStore and the parallel finder is asserted to produce equivalent
-// results (so the cross-adapter Liskov contract holds for the finder family
-// the same way it does for `listNodes` / `bulkLoad`).
-//
-// Fixtures and assertions live entirely inside `packages/storage`; no
-// consumer package is touched here.
-
-import assert from "node:assert/strict";
-import { mkdtemp } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { test } from "node:test";
-import {
-  type GraphNode,
-  KnowledgeGraph,
-  makeNodeId,
-  type NodeId,
-  type RelationType,
-} from "@opencodehub/core-types";
-import { DuckDbStore } from "./duckdb-adapter.js";
-import { GraphDbStore } from "./graphdb-adapter.js";
-import type { EmbeddingRow } from "./interface.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-async function scratchDuckPath(): Promise<string> {
-  const dir = await mkdtemp(join(tmpdir(), "och-finders-duck-"));
-  return join(dir, "graph.duckdb");
-}
-
-async function scratchGraphDbPath(): Promise<string> {
-  const dir = await mkdtemp(join(tmpdir(), "och-finders-gdb-"));
-  return join(dir, "graph.db");
-}
-
-async function hasNativeBinding(): Promise<boolean> {
-  try {
-    await import("@ladybugdb/core");
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Fixture — covers every node kind the typed finders narrow to, plus a small
-// edge mix to exercise listEdges / listEdgesByType / traverseAncestors /
-// traverseDescendants / countEdgesByType / listConsumerProducerEdges.
-// ---------------------------------------------------------------------------
-
-interface FixtureIds {
-  readonly fileA: NodeId;
-  readonly fileB: NodeId;
-  readonly fnFoo: NodeId;
-  readonly fnBar: NodeId;
-  readonly fnBaz: NodeId;
-  readonly route1: NodeId;
-  readonly op1: NodeId;
-  readonly findingNew: NodeId;
-  readonly findingOld: NodeId;
-  readonly findingSuppressed: NodeId;
-  readonly depMit: NodeId;
-  readonly depGpl: NodeId;
-  readonly depUnknown: NodeId;
-  readonly repoConsumer: NodeId;
-  readonly repoProducer: NodeId;
-  readonly procFoo: NodeId;
-}
-
-function buildFinderFixture(): { graph: KnowledgeGraph; ids: FixtureIds } {
-  const g = new KnowledgeGraph();
-  const fileA = makeNodeId("File", "src/a.ts", "a.ts");
-  const fileB = makeNodeId("File", "src/b.ts", "b.ts");
-  g.addNode({ id: fileA, kind: "File", name: "a.ts", filePath: "src/a.ts" });
-  g.addNode({ id: fileB, kind: "File", name: "b.ts", filePath: "src/b.ts" });
-
-  const fnFoo = makeNodeId("Function", "src/a.ts", "foo");
-  const fnBar = makeNodeId("Function", "src/a.ts", "bar");
-  const fnBaz = makeNodeId("Function", "src/b.ts", "baz");
-  g.addNode({
-    id: fnFoo,
-    kind: "Function",
-    name: "foo",
-    filePath: "src/a.ts",
-    isExported: true,
-  });
-  g.addNode({
-    id: fnBar,
-    kind: "Function",
-    name: "bar",
-    filePath: "src/a.ts",
-    isExported: false,
-  });
-  g.addNode({
-    id: fnBaz,
-    kind: "Function",
-    name: "baz",
-    filePath: "src/b.ts",
-    isExported: true,
-  });
-
-  const route1 = makeNodeId("Route", "src/router.ts", "GET /api/users");
-  g.addNode({
-    id: route1,
-    kind: "Route",
-    name: "GET /api/users",
-    filePath: "src/router.ts",
-    method: "GET",
-    url: "/api/users",
-  } as unknown as GraphNode);
-
-  const op1 = makeNodeId("Operation", "openapi.yaml", "GET /api/users");
-  g.addNode({
-    id: op1,
-    kind: "Operation",
-    name: "listUsers",
-    filePath: "openapi.yaml",
-    method: "GET",
-    path: "/api/users",
-  } as unknown as GraphNode);
-
-  const findingNew = makeNodeId("Finding", "src/a.ts", "rule-A#1");
-  g.addNode({
-    id: findingNew,
-    kind: "Finding",
-    name: "rule-A#1",
-    filePath: "src/a.ts",
-    startLine: 5,
-    endLine: 5,
-    ruleId: "rule-A",
-    severity: "error",
-    scannerId: "semgrep",
-    message: "Something bad",
-    propertiesBag: {},
-    baselineState: "new",
-  } as unknown as GraphNode);
-  const findingOld = makeNodeId("Finding", "src/b.ts", "rule-B#1");
-  g.addNode({
-    id: findingOld,
-    kind: "Finding",
-    name: "rule-B#1",
-    filePath: "src/b.ts",
-    startLine: 7,
-    endLine: 7,
-    ruleId: "rule-B",
-    severity: "warning",
-    scannerId: "semgrep",
-    message: "Lint warning",
-    propertiesBag: {},
-    baselineState: "unchanged",
-  } as unknown as GraphNode);
-  const findingSuppressed = makeNodeId("Finding", "src/b.ts", "rule-C#1");
-  g.addNode({
-    id: findingSuppressed,
-    kind: "Finding",
-    name: "rule-C#1",
-    filePath: "src/b.ts",
-    startLine: 9,
-    endLine: 9,
-    ruleId: "rule-C",
-    severity: "note",
-    scannerId: "semgrep",
-    message: "Style nit",
-    propertiesBag: {},
-    baselineState: "unchanged",
-    suppressedJson: '{"rules":["rule-C"],"reasonCategory":"intentional"}',
-  } as unknown as GraphNode);
-
-  const depMit = makeNodeId("Dependency", "package-lock.json", "react@18.2.0");
-  g.addNode({
-    id: depMit,
-    kind: "Dependency",
-    name: "react",
-    filePath: "package-lock.json",
-    version: "18.2.0",
-    ecosystem: "npm",
-    lockfileSource: "package-lock.json",
-    license: "MIT",
-  } as unknown as GraphNode);
-  const depGpl = makeNodeId("Dependency", "package-lock.json", "readline@1.0.0");
-  g.addNode({
-    id: depGpl,
-    kind: "Dependency",
-    name: "readline",
-    filePath: "package-lock.json",
-    version: "1.0.0",
-    ecosystem: "npm",
-    lockfileSource: "package-lock.json",
-    license: "GPL-3.0",
-  } as unknown as GraphNode);
-  const depUnknown = makeNodeId("Dependency", "package-lock.json", "weird-pkg@0.1.0");
-  g.addNode({
-    id: depUnknown,
-    kind: "Dependency",
-    name: "weird-pkg",
-    filePath: "package-lock.json",
-    version: "0.1.0",
-    ecosystem: "npm",
-    lockfileSource: "package-lock.json",
-  } as unknown as GraphNode);
-
-  const repoConsumer = makeNodeId("Repo", "", "consumer");
-  g.addNode({
-    id: repoConsumer,
-    kind: "Repo",
-    name: "github.com/acme/consumer",
-    filePath: "",
-    originUrl: "https://github.com/acme/consumer.git",
-    repoUri: "github.com/acme/consumer",
-    defaultBranch: "main",
-    commitSha: "1111111111111111111111111111111111111111",
-    indexTime: "2026-05-09T00:00:00Z",
-    group: "acme",
-    visibility: "internal",
-    indexer: "opencodehub@0.1.0",
-    languageStats: { ts: 1.0 },
-  } as unknown as GraphNode);
-  // Process node with entry_point_id pointing at fnFoo so listNodesByEntryPoint
-  // has something to match. Two functions on src/a.ts share the name "bar"
-  // would muddle name lookup, so we keep distinct names and use the second
-  // function (fnBar) as a parallel-named entity in a kind-distinct check.
-  const procFoo = makeNodeId("Process", "src/a.ts", "process_foo");
-  g.addNode({
-    id: procFoo,
-    kind: "Process",
-    name: "process_foo",
-    filePath: "src/a.ts",
-    entryPointId: fnFoo,
-    stepCount: 2,
-  } as unknown as GraphNode);
-
-  const repoProducer = makeNodeId("Repo", "", "producer");
-  g.addNode({
-    id: repoProducer,
-    kind: "Repo",
-    name: "github.com/acme/producer",
-    filePath: "",
-    originUrl: null,
-    repoUri: "github.com/acme/producer",
-    defaultBranch: null,
-    commitSha: "2222222222222222222222222222222222222222",
-    indexTime: "2026-05-09T00:00:01Z",
-    group: null,
-    visibility: "private",
-    indexer: "opencodehub@0.1.0",
-    languageStats: {},
-  } as unknown as GraphNode);
-
-  // Edges — form a small DAG so traverseAncestors/Descendants have something
-  // meaningful to walk:
-  //   fileA --DEFINES--> fnFoo --CALLS--> fnBar --CALLS--> fnBaz
-  //   fileA --DEFINES--> fnBar
-  //   fileB --DEFINES--> fnBaz
-  g.addEdge({ from: fileA, to: fnFoo, type: "DEFINES", confidence: 1.0 });
-  g.addEdge({ from: fileA, to: fnBar, type: "DEFINES", confidence: 1.0 });
-  g.addEdge({ from: fileB, to: fnBaz, type: "DEFINES", confidence: 1.0 });
-  g.addEdge({ from: fnFoo, to: fnBar, type: "CALLS", confidence: 0.9 });
-  g.addEdge({ from: fnBar, to: fnBaz, type: "CALLS", confidence: 0.7 });
-
-  // FETCHES edge from a consumer Function on the consumer side to the
-  // Operation on the producer side. The producer carries a `repo_uri`
-  // matching `repoProducer.repoUri` via the persisted Repo column. We
-  // synthesize the cross-repo wiring by adding an Operation node whose
-  // `repo_uri` column will be set after node insertion through the
-  // bulkLoad column encoder.
-  g.addEdge({ from: fnFoo, to: op1, type: "FETCHES", confidence: 0.95 });
-
-  return {
-    graph: g,
-    ids: {
-      fileA,
-      fileB,
-      fnFoo,
-      fnBar,
-      fnBaz,
-      route1,
-      op1,
-      findingNew,
-      findingOld,
-      findingSuppressed,
-      depMit,
-      depGpl,
-      depUnknown,
-      repoConsumer,
-      repoProducer,
-      procFoo,
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Embedding fixture — vectors for two of the function nodes plus a Route node
-// so the listEmbeddings + kindFilter paths have non-trivial coverage.
-// ---------------------------------------------------------------------------
-
-function buildEmbeddingFixture(ids: FixtureIds): readonly EmbeddingRow[] {
-  const dim = 8;
-  const v = (seed: number): Float32Array => {
-    const out = new Float32Array(dim);
-    for (let i = 0; i < dim; i += 1) out[i] = seed + i * 0.1;
-    return out;
-  };
-  return [
-    {
-      nodeId: ids.fnFoo,
-      granularity: "symbol",
-      chunkIndex: 0,
-      vector: v(0.1),
-      contentHash: "hash-foo",
-    },
-    {
-      nodeId: ids.fnBar,
-      granularity: "symbol",
-      chunkIndex: 0,
-      vector: v(0.2),
-      contentHash: "hash-bar",
-    },
-    {
-      nodeId: ids.route1,
-      granularity: "symbol",
-      chunkIndex: 0,
-      vector: v(0.3),
-      contentHash: "hash-route",
-    },
-  ];
-}
-
-// ---------------------------------------------------------------------------
-// DuckDb finder tests
-// ---------------------------------------------------------------------------
-
-async function withDuckStore(
-  fn: (store: DuckDbStore, ids: FixtureIds) => Promise<void>,
-): Promise<void> {
-  const path = await scratchDuckPath();
-  const store = new DuckDbStore(path, { embeddingDim: 8 });
-  await store.open();
-  try {
-    await store.createSchema();
-    const { graph, ids } = buildFinderFixture();
-    await store.bulkLoad(graph);
-    await fn(store, ids);
-  } finally {
-    await store.close();
-  }
-}
-
-test("DuckDb listNodesByKind narrows by kind discriminator", async () => {
-  await withDuckStore(async (store, ids) => {
-    const findings = await store.listNodesByKind("Finding");
-    assert.equal(findings.length, 3);
-    for (const f of findings) {
-      assert.equal(f.kind, "Finding");
-    }
-    // Determinism: two calls return deeply-equal arrays.
-    const second = await store.listNodesByKind("Finding");
-    assert.deepEqual(findings, second);
-
-    // filePath / filePathLike narrow correctly.
-    const onlyA = await store.listNodesByKind("Function", { filePath: "src/a.ts" });
-    assert.equal(onlyA.length, 2);
-    const aIds = onlyA.map((n) => n.id).sort();
-    assert.deepEqual(aIds, [ids.fnBar, ids.fnFoo].sort());
-
-    const matchSrc = await store.listNodesByKind("Function", { filePathLike: "src/" });
-    assert.equal(matchSrc.length, 3);
-  });
-});
-
-test("DuckDb listEdges + listEdgesByType return typed edges in deterministic order", async () => {
-  await withDuckStore(async (store) => {
-    const allEdges = await store.listEdges();
-    assert.equal(allEdges.length, 6); // 3 DEFINES + 2 CALLS + 1 FETCHES
-
-    const defines = await store.listEdgesByType("DEFINES");
-    assert.equal(defines.length, 3);
-    for (const e of defines) assert.equal(e.type, "DEFINES");
-
-    // Determinism: two calls deeply equal.
-    const definesAgain = await store.listEdgesByType("DEFINES");
-    assert.deepEqual(defines, definesAgain);
-
-    // Confidence floor.
-    const highConfidence = await store.listEdges({ minConfidence: 0.95 });
-    assert.ok(highConfidence.every((e) => e.confidence >= 0.95));
-  });
-});
-
-test("DuckDb listFindings filters by severity, ruleId, baselineState, suppressed", async () => {
-  await withDuckStore(async (store) => {
-    const errors = await store.listFindings({ severity: ["error"] });
-    assert.equal(errors.length, 1);
-    assert.equal(errors[0]?.severity, "error");
-
-    const byRule = await store.listFindings({ ruleId: "rule-B" });
-    assert.equal(byRule.length, 1);
-    assert.equal(byRule[0]?.ruleId, "rule-B");
-
-    const newOnes = await store.listFindings({ baselineState: ["new"] });
-    assert.equal(newOnes.length, 1);
-
-    const suppressed = await store.listFindings({ suppressed: true });
-    assert.equal(suppressed.length, 1);
-    const nonSuppressed = await store.listFindings({ suppressed: false });
-    assert.equal(nonSuppressed.length, 2);
-  });
-});
-
-test("DuckDb listDependencies filters by ecosystem + license tier", async () => {
-  await withDuckStore(async (store) => {
-    const allNpm = await store.listDependencies({ ecosystem: "npm" });
-    assert.equal(allNpm.length, 3);
-
-    const permissive = await store.listDependencies({ licenseTier: ["permissive"] });
-    assert.equal(permissive.length, 1);
-    assert.equal(permissive[0]?.license, "MIT");
-
-    const strong = await store.listDependencies({ licenseTier: ["strong-copyleft"] });
-    assert.equal(strong.length, 1);
-    assert.equal(strong[0]?.license, "GPL-3.0");
-
-    const unknown = await store.listDependencies({ licenseTier: ["unknown"] });
-    assert.equal(unknown.length, 1);
-  });
-});
-
-test("DuckDb listRoutes filters by methods + pathLike", async () => {
-  await withDuckStore(async (store) => {
-    const all = await store.listRoutes();
-    assert.equal(all.length, 1);
-    assert.equal(all[0]?.method, "GET");
-
-    const post = await store.listRoutes({ methods: ["POST"] });
-    assert.equal(post.length, 0);
-
-    const apiPath = await store.listRoutes({ pathLike: "/api" });
-    assert.equal(apiPath.length, 1);
-  });
-});
-
-test("DuckDb getRepoNode returns typed RepoNode or undefined", async () => {
-  await withDuckStore(async (store, ids) => {
-    const repo = await store.getRepoNode(ids.repoConsumer);
-    assert.ok(repo);
-    assert.equal(repo?.kind, "Repo");
-    assert.equal(repo?.repoUri, "github.com/acme/consumer");
-    assert.equal(repo?.defaultBranch, "main");
-
-    // Explicit null preservation for the producer (no origin / branch / group).
-    const producer = await store.getRepoNode(ids.repoProducer);
-    assert.ok(producer);
-    assert.equal(producer?.originUrl, null);
-    assert.equal(producer?.defaultBranch, null);
-    assert.equal(producer?.group, null);
-
-    const missing = await store.getRepoNode("nope");
-    assert.equal(missing, undefined);
-
-    // Non-Repo id returns undefined (caller never has to downcast).
-    const notARepo = await store.getRepoNode(ids.fnFoo);
-    assert.equal(notARepo, undefined);
-  });
-});
-
-test("DuckDb countNodesByKind + countEdgesByType return Maps with deterministic counts", async () => {
-  await withDuckStore(async (store) => {
-    const nodeCounts = await store.countNodesByKind();
-    assert.equal(nodeCounts.get("Finding"), 3);
-    assert.equal(nodeCounts.get("Function"), 3);
-    assert.equal(nodeCounts.get("Dependency"), 3);
-    assert.equal(nodeCounts.get("Repo"), 2);
-    assert.equal(nodeCounts.get("Route"), 1);
-    assert.equal(nodeCounts.get("Operation"), 1);
-    assert.equal(nodeCounts.get("File"), 2);
-
-    // Backfill: ask about a kind that has zero rows.
-    const partial = await store.countNodesByKind(["Function", "Trait"]);
-    assert.equal(partial.get("Function"), 3);
-    assert.equal(partial.get("Trait"), 0);
-
-    const edgeCounts = await store.countEdgesByType();
-    assert.equal(edgeCounts.get("DEFINES"), 3);
-    assert.equal(edgeCounts.get("CALLS"), 2);
-    assert.equal(edgeCounts.get("FETCHES"), 1);
-
-    // Empty input → empty map (per the contract).
-    const emptyN = await store.countNodesByKind([]);
-    assert.equal(emptyN.size, 0);
-    const emptyE = await store.countEdgesByType([]);
-    assert.equal(emptyE.size, 0);
-  });
-});
-
-test("DuckDb listNodes filters by ids", async () => {
-  await withDuckStore(async (store, ids) => {
-    const subset = await store.listNodes({ ids: [ids.fnFoo, ids.fnBar] });
-    assert.equal(subset.length, 2);
-    const subsetIds = subset.map((n) => n.id).sort();
-    assert.deepEqual(subsetIds, [ids.fnBar, ids.fnFoo].sort());
-
-    // Determinism: same call → same array.
-    const subsetAgain = await store.listNodes({ ids: [ids.fnFoo, ids.fnBar] });
-    assert.deepEqual(subset, subsetAgain);
-
-    // Empty ids → empty array (no SQL round-trip).
-    const empty = await store.listNodes({ ids: [] });
-    assert.equal(empty.length, 0);
-
-    // De-duplication: passing duplicates returns at most one row per id.
-    const dedup = await store.listNodes({ ids: [ids.fnFoo, ids.fnFoo, ids.fnFoo] });
-    assert.equal(dedup.length, 1);
-
-    // AND-combined with kinds.
-    const fnOnly = await store.listNodes({ ids: [ids.fnFoo, ids.fileA], kinds: ["Function"] });
-    assert.equal(fnOnly.length, 1);
-    assert.equal(fnOnly[0]?.id, ids.fnFoo);
-
-    // Unknown id yields zero rows, not an error.
-    const missing = await store.listNodes({ ids: ["nope"] });
-    assert.equal(missing.length, 0);
-  });
-});
-
-test("DuckDb listNodesByEntryPoint matches the entry_point_id column", async () => {
-  await withDuckStore(async (store, ids) => {
-    const matched = await store.listNodesByEntryPoint(ids.fnFoo);
-    assert.equal(matched.length, 1);
-    assert.equal(matched[0]?.id, ids.procFoo);
-    assert.equal(matched[0]?.kind, "Process");
-
-    // Determinism: deeply-equal arrays across calls.
-    const again = await store.listNodesByEntryPoint(ids.fnFoo);
-    assert.deepEqual(matched, again);
-
-    // No matches → empty array.
-    const none = await store.listNodesByEntryPoint("never-set");
-    assert.equal(none.length, 0);
-  });
-});
-
-test("DuckDb listNodesByName matches name + optional kinds + filePath", async () => {
-  await withDuckStore(async (store, ids) => {
-    // Single name → exactly the one Function node "foo".
-    const foo = await store.listNodesByName("foo");
-    assert.equal(foo.length, 1);
-    assert.equal(foo[0]?.id, ids.fnFoo);
-
-    // No matches → empty.
-    const noSuch = await store.listNodesByName("does-not-exist");
-    assert.equal(noSuch.length, 0);
-
-    // kinds filter narrows.
-    const fnFoo = await store.listNodesByName("foo", { kinds: ["Function"] });
-    assert.equal(fnFoo.length, 1);
-    assert.equal(fnFoo[0]?.id, ids.fnFoo);
-
-    // Empty kinds → short-circuits to [].
-    const emptyKinds = await store.listNodesByName("foo", { kinds: [] });
-    assert.equal(emptyKinds.length, 0);
-
-    // filePath filter narrows.
-    const onA = await store.listNodesByName("foo", { filePath: "src/a.ts" });
-    assert.equal(onA.length, 1);
-    assert.equal(onA[0]?.id, ids.fnFoo);
-    const onB = await store.listNodesByName("foo", { filePath: "src/b.ts" });
-    assert.equal(onB.length, 0);
-  });
-});
-
-test("DuckDb traverseAncestors + traverseDescendants walk the small DAG", async () => {
-  await withDuckStore(async (store, ids) => {
-    // Descendants of fnFoo via CALLS up to depth 2: fnBar (1), fnBaz (2).
-    const descendants = await store.traverseDescendants({
-      fromId: ids.fnFoo,
-      edgeTypes: ["CALLS"],
-      maxDepth: 5,
-    });
-    assert.deepEqual(descendants.map((r) => r.nodeId).sort(), [ids.fnBar, ids.fnBaz].sort());
-
-    // Ancestors of fnBaz via CALLS: fnBar (1), fnFoo (2).
-    const ancestors = await store.traverseAncestors({
-      fromId: ids.fnBaz,
-      edgeTypes: ["CALLS"],
-      maxDepth: 5,
-    });
-    assert.deepEqual(ancestors.map((r) => r.nodeId).sort(), [ids.fnBar, ids.fnFoo].sort());
-
-    // Empty edgeTypes → empty result (no traversal).
-    const empty = await store.traverseAncestors({
-      fromId: ids.fnBaz,
-      edgeTypes: [],
-      maxDepth: 5,
-    });
-    assert.deepEqual(empty, []);
-  });
-});
-
-test("DuckDb listEmbeddings streams rows in deterministic order", async () => {
-  await withDuckStore(async (store, ids) => {
-    const fixture = buildEmbeddingFixture(ids);
-    await store.upsertEmbeddings(fixture);
-
-    const rowsOne: EmbeddingRow[] = [];
-    for await (const row of store.listEmbeddings()) {
-      rowsOne.push(row);
-    }
-    assert.equal(rowsOne.length, 3);
-
-    const rowsTwo: EmbeddingRow[] = [];
-    for await (const row of store.listEmbeddings()) {
-      rowsTwo.push(row);
-    }
-    assert.equal(rowsTwo.length, 3);
-    // Determinism: same ordering across calls.
-    assert.deepEqual(
-      rowsOne.map((r) => `${r.nodeId}|${r.granularity}|${r.chunkIndex}`),
-      rowsTwo.map((r) => `${r.nodeId}|${r.granularity}|${r.chunkIndex}`),
-    );
-
-    // kindFilter narrows the stream.
-    const onlyFunctions: EmbeddingRow[] = [];
-    for await (const row of store.listEmbeddings({ kindFilter: ["Function"] })) {
-      onlyFunctions.push(row);
-    }
-    assert.equal(onlyFunctions.length, 2);
-
-    // Empty kindFilter short-circuits.
-    const none: EmbeddingRow[] = [];
-    for await (const row of store.listEmbeddings({ kindFilter: [] })) {
-      none.push(row);
-    }
-    assert.equal(none.length, 0);
-  });
-});
-
-test("DuckDb listConsumerProducerEdges returns the FETCHES + Operation join", async () => {
-  // The fixture's FETCHES edge crosses repo boundaries only when the consumer
-  // and producer nodes carry their own repo_uri columns. Our fixture leaves
-  // those columns NULL on Function/Operation nodes (only Repo nodes carry
-  // repo_uri today), so the cross-repo predicate resolves to the empty
-  // string for both endpoints. This test confirms the SHAPE of the result
-  // — the full cross-repo join is exercised by the cross-repo contract
-  // integration suites, which run against repos whose ingestion has
-  // populated repo_uri on every node.
-  await withDuckStore(async (store) => {
-    const edges = await store.listConsumerProducerEdges();
-    assert.equal(edges.length, 1);
-    const edge = edges[0];
-    assert.ok(edge);
-    assert.equal(edge?.httpMethod, "GET");
-    assert.equal(edge?.httpPath, "/api/users");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// GraphDb finder tests — gated on the native binding being available.
-// ---------------------------------------------------------------------------
-
-async function withGraphDbStore(
-  fn: (store: GraphDbStore, ids: FixtureIds) => Promise<void>,
-): Promise<void> {
-  if (!(await hasNativeBinding())) {
-    return;
-  }
-  const path = await scratchGraphDbPath();
-  const store = new GraphDbStore(path, { embeddingDim: 8 });
-  await store.open();
-  try {
-    await store.createSchema();
-    const { graph, ids } = buildFinderFixture();
-    await store.bulkLoad(graph);
-    await fn(store, ids);
-  } finally {
-    await store.close();
-  }
-}
-
-test("GraphDb listNodesByKind narrows by kind discriminator", async () => {
-  if (!(await hasNativeBinding())) {
-    assert.ok(true, "native binding unavailable — skipping");
-    return;
-  }
-  await withGraphDbStore(async (store) => {
-    const findings = await store.listNodesByKind("Finding");
-    assert.equal(findings.length, 3);
-    for (const f of findings) assert.equal(f.kind, "Finding");
-    const second = await store.listNodesByKind("Finding");
-    assert.deepEqual(findings, second);
-
-    const onlyA = await store.listNodesByKind("Function", { filePath: "src/a.ts" });
-    assert.equal(onlyA.length, 2);
-  });
-});
-
-test("GraphDb listEdges + listEdgesByType return typed edges in deterministic order", async () => {
-  if (!(await hasNativeBinding())) {
-    assert.ok(true, "native binding unavailable — skipping");
-    return;
-  }
-  await withGraphDbStore(async (store) => {
-    const allEdges = await store.listEdges();
-    assert.equal(allEdges.length, 6);
-
-    const defines = await store.listEdgesByType("DEFINES");
-    assert.equal(defines.length, 3);
-    for (const e of defines) assert.equal(e.type, "DEFINES");
-
-    const definesAgain = await store.listEdgesByType("DEFINES");
-    assert.deepEqual(defines, definesAgain);
-  });
-});
-
-test("GraphDb listFindings filters by severity, ruleId, baselineState, suppressed", async () => {
-  if (!(await hasNativeBinding())) {
-    assert.ok(true, "native binding unavailable — skipping");
-    return;
-  }
-  await withGraphDbStore(async (store) => {
-    const errors = await store.listFindings({ severity: ["error"] });
-    assert.equal(errors.length, 1);
-
-    const byRule = await store.listFindings({ ruleId: "rule-B" });
-    assert.equal(byRule.length, 1);
-
-    const newOnes = await store.listFindings({ baselineState: ["new"] });
-    assert.equal(newOnes.length, 1);
-
-    const suppressed = await store.listFindings({ suppressed: true });
-    assert.equal(suppressed.length, 1);
-    const nonSuppressed = await store.listFindings({ suppressed: false });
-    assert.equal(nonSuppressed.length, 2);
-  });
-});
-
-test("GraphDb listDependencies filters by ecosystem + license tier", async () => {
-  if (!(await hasNativeBinding())) {
-    assert.ok(true, "native binding unavailable — skipping");
-    return;
-  }
-  await withGraphDbStore(async (store) => {
-    const allNpm = await store.listDependencies({ ecosystem: "npm" });
-    assert.equal(allNpm.length, 3);
-
-    const permissive = await store.listDependencies({ licenseTier: ["permissive"] });
-    assert.equal(permissive.length, 1);
-
-    const strong = await store.listDependencies({ licenseTier: ["strong-copyleft"] });
-    assert.equal(strong.length, 1);
-  });
-});
-
-test("GraphDb listRoutes filters by methods + pathLike", async () => {
-  if (!(await hasNativeBinding())) {
-    assert.ok(true, "native binding unavailable — skipping");
-    return;
-  }
-  await withGraphDbStore(async (store) => {
-    const all = await store.listRoutes();
-    assert.equal(all.length, 1);
-    const apiPath = await store.listRoutes({ pathLike: "/api" });
-    assert.equal(apiPath.length, 1);
-  });
-});
-
-test("GraphDb getRepoNode returns typed RepoNode or undefined", async () => {
-  if (!(await hasNativeBinding())) {
-    assert.ok(true, "native binding unavailable — skipping");
-    return;
-  }
-  await withGraphDbStore(async (store, ids) => {
-    const repo = await store.getRepoNode(ids.repoConsumer);
-    assert.ok(repo);
-    assert.equal(repo?.repoUri, "github.com/acme/consumer");
-    const missing = await store.getRepoNode("nope");
-    assert.equal(missing, undefined);
-    const notARepo = await store.getRepoNode(ids.fnFoo);
-    assert.equal(notARepo, undefined);
-  });
-});
-
-test("GraphDb countNodesByKind + countEdgesByType return Maps with deterministic counts", async () => {
-  if (!(await hasNativeBinding())) {
-    assert.ok(true, "native binding unavailable — skipping");
-    return;
-  }
-  await withGraphDbStore(async (store) => {
-    const nodeCounts = await store.countNodesByKind();
-    assert.equal(nodeCounts.get("Function"), 3);
-    assert.equal(nodeCounts.get("Finding"), 3);
-
-    const edgeCounts = await store.countEdgesByType([
-      "DEFINES",
-      "CALLS",
-      "FETCHES",
-    ] as const satisfies readonly RelationType[]);
-    assert.equal(edgeCounts.get("DEFINES"), 3);
-    assert.equal(edgeCounts.get("CALLS"), 2);
-    assert.equal(edgeCounts.get("FETCHES"), 1);
-  });
-});
-
-test("GraphDb listNodes filters by ids", async () => {
-  if (!(await hasNativeBinding())) {
-    assert.ok(true, "native binding unavailable — skipping");
-    return;
-  }
-  await withGraphDbStore(async (store, ids) => {
-    const subset = await store.listNodes({ ids: [ids.fnFoo, ids.fnBar] });
-    assert.equal(subset.length, 2);
-    const empty = await store.listNodes({ ids: [] });
-    assert.equal(empty.length, 0);
-    const fnOnly = await store.listNodes({ ids: [ids.fnFoo, ids.fileA], kinds: ["Function"] });
-    assert.equal(fnOnly.length, 1);
-    assert.equal(fnOnly[0]?.id, ids.fnFoo);
-  });
-});
-
-test("GraphDb listNodesByEntryPoint matches the entry_point_id column", async () => {
-  if (!(await hasNativeBinding())) {
-    assert.ok(true, "native binding unavailable — skipping");
-    return;
-  }
-  await withGraphDbStore(async (store, ids) => {
-    const matched = await store.listNodesByEntryPoint(ids.fnFoo);
-    assert.equal(matched.length, 1);
-    assert.equal(matched[0]?.id, ids.procFoo);
-    const none = await store.listNodesByEntryPoint("never-set");
-    assert.equal(none.length, 0);
-  });
-});
-
-test("GraphDb listNodesByName matches name + optional kinds + filePath", async () => {
-  if (!(await hasNativeBinding())) {
-    assert.ok(true, "native binding unavailable — skipping");
-    return;
-  }
-  await withGraphDbStore(async (store, ids) => {
-    const foo = await store.listNodesByName("foo");
-    assert.equal(foo.length, 1);
-    assert.equal(foo[0]?.id, ids.fnFoo);
-    const noSuch = await store.listNodesByName("does-not-exist");
-    assert.equal(noSuch.length, 0);
-    const fnFoo = await store.listNodesByName("foo", { kinds: ["Function"] });
-    assert.equal(fnFoo.length, 1);
-    const emptyKinds = await store.listNodesByName("foo", { kinds: [] });
-    assert.equal(emptyKinds.length, 0);
-    const onA = await store.listNodesByName("foo", { filePath: "src/a.ts" });
-    assert.equal(onA.length, 1);
-  });
-});
-
-test("GraphDb traverseAncestors + traverseDescendants walk the small DAG", async () => {
-  if (!(await hasNativeBinding())) {
-    assert.ok(true, "native binding unavailable — skipping");
-    return;
-  }
-  await withGraphDbStore(async (store, ids) => {
-    const descendants = await store.traverseDescendants({
-      fromId: ids.fnFoo,
-      edgeTypes: ["CALLS"],
-      maxDepth: 5,
-    });
-    assert.deepEqual(descendants.map((r) => r.nodeId).sort(), [ids.fnBar, ids.fnBaz].sort());
-
-    const ancestors = await store.traverseAncestors({
-      fromId: ids.fnBaz,
-      edgeTypes: ["CALLS"],
-      maxDepth: 5,
-    });
-    assert.deepEqual(ancestors.map((r) => r.nodeId).sort(), [ids.fnBar, ids.fnFoo].sort());
-  });
-});
-
-test("GraphDb listEmbeddings streams rows in deterministic order", async () => {
-  if (!(await hasNativeBinding())) {
-    assert.ok(true, "native binding unavailable — skipping");
-    return;
-  }
-  await withGraphDbStore(async (store, ids) => {
-    const fixture = buildEmbeddingFixture(ids);
-    await store.upsertEmbeddings(fixture);
-    const rowsOne: EmbeddingRow[] = [];
-    for await (const row of store.listEmbeddings()) rowsOne.push(row);
-    assert.equal(rowsOne.length, 3);
-    const rowsTwo: EmbeddingRow[] = [];
-    for await (const row of store.listEmbeddings()) rowsTwo.push(row);
-    assert.deepEqual(
-      rowsOne.map((r) => `${r.nodeId}|${r.granularity}|${r.chunkIndex}`),
-      rowsTwo.map((r) => `${r.nodeId}|${r.granularity}|${r.chunkIndex}`),
-    );
-  });
-});
-
-test("GraphDb listConsumerProducerEdges returns the FETCHES + Operation join", async () => {
-  if (!(await hasNativeBinding())) {
-    assert.ok(true, "native binding unavailable — skipping");
-    return;
-  }
-  await withGraphDbStore(async (store) => {
-    const edges = await store.listConsumerProducerEdges();
-    assert.equal(edges.length, 1);
-    const edge = edges[0];
-    assert.ok(edge);
-    assert.equal(edge?.httpMethod, "GET");
-    assert.equal(edge?.httpPath, "/api/users");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Cross-adapter parity — when both backends are available, listNodes /
-// listEdges / countNodesByKind / countEdgesByType produce identical counts.
-// ---------------------------------------------------------------------------
-
-test("DuckDb and GraphDb agree on countNodesByKind across the same fixture", async () => {
-  if (!(await hasNativeBinding())) {
-    assert.ok(true, "native binding unavailable — skipping cross-adapter parity");
-    return;
-  }
-  const duckPath = await scratchDuckPath();
-  const duck = new DuckDbStore(duckPath, { embeddingDim: 8 });
-  await duck.open();
-  await duck.createSchema();
-  const { graph } = buildFinderFixture();
-  await duck.bulkLoad(graph);
-
-  const gdbPath = await scratchGraphDbPath();
-  const gdb = new GraphDbStore(gdbPath, { embeddingDim: 8 });
-  await gdb.open();
-  try {
-    await gdb.createSchema();
-    await gdb.bulkLoad(graph);
-
-    const duckCounts = await duck.countNodesByKind();
-    const gdbCounts = await gdb.countNodesByKind();
-    // Convert both to plain objects so deepEqual works regardless of Map
-    // iteration order.
-    const sortedDuck = Object.fromEntries([...duckCounts.entries()].sort());
-    const sortedGdb = Object.fromEntries([...gdbCounts.entries()].sort());
-    assert.deepEqual(sortedDuck, sortedGdb);
-  } finally {
-    await duck.close();
-    await gdb.close();
-  }
-});
diff --git a/packages/storage/src/graph-hash-parity.test.ts b/packages/storage/src/graph-hash-parity.test.ts
deleted file mode 100644
index 829061bf..00000000
--- a/packages/storage/src/graph-hash-parity.test.ts
+++ /dev/null
@@ -1,571 +0,0 @@
-/**
- * graphHash parity gate.
- *
- * Enforces the v1.0 byte-identity invariant across every IGraphStore
- * backend: for every fixture graph,
- *
- *   graphHash(graph)
- *     === graphHash(rebuildFromStore(duckGraph))
- *     === graphHash(rebuildFromStore(graphDbGraph))
- *
- * If these hashes diverge, one of the adapters dropped, reordered, or
- * coerced a field on the round-trip — which would silently break the
- * incremental re-index contract and the Reindex parity gate. This file
- * is the CI tripwire.
- *
- * The per-backend rebuilders live in `./test-utils/parity-harness.ts`.
- * The parity harness uses ONLY `IGraphStore.listNodes({})` +
- * `IGraphStore.listEdges({})` — a third-party AGE / Memgraph / Neo4j /
- * Neptune adapter can prove conformance by importing `assertGraphParity`
- * from `@opencodehub/storage/test-utils` and running it against its own
- * adapter. This test reduces to fixture builders + a single
- * `assertGraphParity` call per fixture.
- *
- * Three fixtures exercise progressively larger shapes:
- *   - small:  ≤10 nodes, DEFINES + CALLS only (sanity shape).
- *   - medium: ~60 nodes with File / Class / Interface / Method /
- *             Contributor, mixing DEFINES / IMPLEMENTS / HAS_METHOD /
- *             CALLS / OWNED_BY so the v1.1 node + edge surface is visible.
- *   - large:  ≥500 nodes built as a long CALLS chain with shortcuts, plus
- *             a companion sweep that emits at least one edge for every
- *             entry in `getAllRelationTypes()` (24 kinds today).
- *   - repo / repo-null: RepoNode round-trip — populated AND explicit-null
- *             variants of `originUrl` / `defaultBranch` / `group`.
- *
- * Step-zero contract: both adapters' read paths drop `step` when the
- * stored value reads back as 0/null so the rebuilt graph is byte-
- * identical across backends. Fixtures avoid `step: 0` anyway to keep
- * the original-graph comparison clean.
- */
-
-import { mkdtemp } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { test } from "node:test";
-import {
-  graphHash,
-  KnowledgeGraph,
-  makeNodeId,
-  type NodeId,
-  type RelationType,
-} from "@opencodehub/core-types";
-import { DuckDbStore } from "./duckdb-adapter.js";
-import { GraphDbStore } from "./graphdb-adapter.js";
-import { getAllRelationTypes } from "./graphdb-schema.js";
-import type { IGraphStore } from "./interface.js";
-import { assertGraphParity } from "./test-utils/parity-harness.js";
-
-// ---------------------------------------------------------------------------
-// Scratch path helpers
-// ---------------------------------------------------------------------------
-
-async function scratchDuckPath(): Promise<string> {
-  const dir = await mkdtemp(join(tmpdir(), "och-parity-duck-"));
-  return join(dir, "graph.duckdb");
-}
-
-async function scratchGraphDbPath(): Promise<string> {
-  const dir = await mkdtemp(join(tmpdir(), "och-parity-graphdb-"));
-  return join(dir, "graph.db");
-}
-
-async function hasGraphDbBinding(): Promise<boolean> {
-  try {
-    await import("@ladybugdb/core");
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Fixture builders
-// ---------------------------------------------------------------------------
-//
-// Fixtures deliberately avoid `step: 0` — when an edge's step is explicitly
-// zero the DuckDB INTEGER NOT NULL column stores 0 while the graph-db
-// nullable INT32 stores 0; the adapters drop step-when-zero on read so the
-// rebuilt graph is symmetric, but the ORIGINAL graph would still carry
-// `step: 0` and canonical-JSON would emit it, breaking the original ===
-// rebuilt assertion. Using step ≥ 1 everywhere sidesteps this.
-
-function buildSmallFixture(): KnowledgeGraph {
-  const g = new KnowledgeGraph();
-  const fileA = makeNodeId("File", "src/a.ts", "a.ts");
-  const fileB = makeNodeId("File", "src/b.ts", "b.ts");
-  g.addNode({ id: fileA, kind: "File", name: "a.ts", filePath: "src/a.ts" });
-  g.addNode({ id: fileB, kind: "File", name: "b.ts", filePath: "src/b.ts" });
-
-  const funcs: NodeId[] = [];
-  for (let i = 0; i < 6; i += 1) {
-    const file = i % 2 === 0 ? "src/a.ts" : "src/b.ts";
-    const id = makeNodeId("Function", file, `fn_${i}`, { parameterCount: i % 3 });
-    funcs.push(id);
-    g.addNode({
-      id,
-      kind: "Function",
-      name: `fn_${i}`,
-      filePath: file,
-      startLine: 10 + i,
-      endLine: 20 + i,
-      signature: `function fn_${i}()`,
-      parameterCount: i % 3,
-      isExported: i % 2 === 0,
-    });
-  }
-  for (let i = 0; i < funcs.length; i += 1) {
-    const from = i % 2 === 0 ? fileA : fileB;
-    g.addEdge({ from, to: funcs[i] as NodeId, type: "DEFINES", confidence: 1.0 });
-  }
-  for (let i = 0; i + 1 < funcs.length; i += 1) {
-    g.addEdge({
-      from: funcs[i] as NodeId,
-      to: funcs[i + 1] as NodeId,
-      type: "CALLS",
-      confidence: 0.9,
-    });
-  }
-  return g;
-}
-
-function buildMediumFixture(): KnowledgeGraph {
-  const g = new KnowledgeGraph();
-
-  const files: NodeId[] = [];
-  for (let i = 0; i < 6; i += 1) {
-    const path = `src/mod${i}/entry.ts`;
-    const id = makeNodeId("File", path, path);
-    files.push(id);
-    g.addNode({
-      id,
-      kind: "File",
-      name: "entry.ts",
-      filePath: path,
-      contentHash: `hash-${i}`,
-    });
-  }
-
-  const classes: NodeId[] = [];
-  for (let i = 0; i < 6; i += 1) {
-    const file = `src/mod${i}/entry.ts`;
-    const clsId = makeNodeId("Class", file, `Service${i}`);
-    classes.push(clsId);
-    g.addNode({
-      id: clsId,
-      kind: "Class",
-      name: `Service${i}`,
-      filePath: file,
-      startLine: 5,
-      endLine: 40,
-      isExported: true,
-    });
-    const ifaceId = makeNodeId("Interface", file, `IService${i}`);
-    g.addNode({
-      id: ifaceId,
-      kind: "Interface",
-      name: `IService${i}`,
-      filePath: file,
-      isExported: true,
-    });
-    const fileId = files[i];
-    if (!fileId) throw new Error("unreachable");
-    g.addEdge({ from: fileId, to: clsId, type: "DEFINES", confidence: 1.0 });
-    g.addEdge({ from: fileId, to: ifaceId, type: "DEFINES", confidence: 1.0 });
-    g.addEdge({ from: clsId, to: ifaceId, type: "IMPLEMENTS", confidence: 1.0 });
-  }
-
-  const methods: NodeId[] = [];
-  for (let i = 0; i < 6; i += 1) {
-    const file = `src/mod${i}/entry.ts`;
-    for (let j = 0; j < 3; j += 1) {
-      const mId = makeNodeId("Method", file, `Service${i}.method${j}`);
-      methods.push(mId);
-      g.addNode({
-        id: mId,
-        kind: "Method",
-        name: `method${j}`,
-        filePath: file,
-        startLine: 10 + j,
-        endLine: 15 + j,
-        parameterCount: j,
-        signature: `method${j}()`,
-      });
-      const clsId = classes[i];
-      if (!clsId) throw new Error("unreachable");
-      g.addEdge({ from: clsId, to: mId, type: "HAS_METHOD", confidence: 1.0 });
-    }
-  }
-
-  // Cross-method CALLS with reason + step ≥ 1.
-  for (let i = 0; i + 1 < methods.length; i += 2) {
-    const from = methods[i];
-    const to = methods[i + 1];
-    if (!from || !to) throw new Error("unreachable");
-    g.addEdge({ from, to, type: "CALLS", confidence: 0.8, reason: "fixture" });
-  }
-  for (let i = 2; i < methods.length; i += 3) {
-    const from = methods[i];
-    const to = methods[(i + 5) % methods.length];
-    if (!from || !to) throw new Error("unreachable");
-    g.addEdge({ from, to, type: "CALLS", confidence: 0.6, step: 1 });
-  }
-
-  // Contributor + ownership.
-  const contributor = makeNodeId("Contributor", "<global>", "alice@example.com");
-  g.addNode({
-    id: contributor,
-    kind: "Contributor",
-    name: "alice",
-    filePath: "<global>",
-    emailHash: "hashed",
-    emailPlain: "alice@example.com",
-  });
-  for (const file of files) {
-    g.addEdge({ from: file, to: contributor, type: "OWNED_BY", confidence: 1.0 });
-  }
-
-  return g;
-}
-
-/**
- * Large fixture with ≥500 nodes AND at least one edge for every declared
- * relation type. Built as one File + 500 Functions in a long DEFINES fan
- * and a CALLS chain with shortcuts, plus a follow-up sweep that attaches
- * one edge of every `getAllRelationTypes()` kind between dedicated anchor
- * nodes — so a schema regression that silently drops a rel table surfaces
- * as a hash mismatch.
- */
-function buildLargeFixture(): KnowledgeGraph {
-  const g = new KnowledgeGraph();
-  const N = 500;
-  const file = makeNodeId("File", "src/chain.ts", "chain.ts");
-  g.addNode({ id: file, kind: "File", name: "chain.ts", filePath: "src/chain.ts" });
-
-  const funcs: NodeId[] = [];
-  for (let i = 0; i < N; i += 1) {
-    const id = makeNodeId("Function", "src/chain.ts", `step_${i}`);
-    funcs.push(id);
-    g.addNode({
-      id,
-      kind: "Function",
-      name: `step_${i}`,
-      filePath: "src/chain.ts",
-      startLine: 10 + i,
-      endLine: 12 + i,
-      signature: `function step_${i}()`,
-      parameterCount: i % 4,
-      isExported: i === 0 || i === N - 1,
-    });
-    g.addEdge({ from: file, to: id, type: "DEFINES", confidence: 1.0 });
-  }
-  for (let i = 0; i + 1 < N; i += 1) {
-    g.addEdge({
-      from: funcs[i] as NodeId,
-      to: funcs[i + 1] as NodeId,
-      type: "CALLS",
-      confidence: 0.95,
-    });
-  }
-  // Non-tree shortcuts with explicit step ≥ 1.
-  for (let i = 0; i + 10 < N; i += 10) {
-    g.addEdge({
-      from: funcs[i] as NodeId,
-      to: funcs[i + 10] as NodeId,
-      type: "CALLS",
-      confidence: 0.5,
-      step: 1,
-    });
-  }
-
-  // All-kinds sweep. One anchor node per edge — we build N_rel + 1 anchors
-  // and emit anchor[i] --kind[i]--> anchor[i+1]. Anchors live in their own
-  // file so they don't collide with the chain Functions above. Step starts
-  // at 1 to dodge the step-zero sentinel.
-  const relationTypes = getAllRelationTypes();
-  const anchors: NodeId[] = [];
-  for (let i = 0; i < relationTypes.length + 1; i += 1) {
-    const id = makeNodeId("Function", `src/anchors/a${i}.ts`, `anchor_${i}`);
-    anchors.push(id);
-    g.addNode({ id, kind: "Function", name: `anchor_${i}`, filePath: `src/anchors/a${i}.ts` });
-  }
-  for (let i = 0; i < relationTypes.length; i += 1) {
-    const from = anchors[i];
-    const to = anchors[i + 1];
-    const kind = relationTypes[i];
-    if (!from || !to || !kind) throw new Error("unreachable");
-    g.addEdge({
-      from,
-      to,
-      type: kind as RelationType,
-      confidence: 0.5 + i * 0.01,
-      reason: `fixture-${i}`,
-      step: i + 1,
-    });
-  }
-
-  return g;
-}
-
-/**
- * Empty-collection fixture: medium graph plus a Community node carrying
- * an explicitly-empty `keywords: []` and a Route node carrying an
- * explicitly-empty `responseKeys: []`. Asserts:
- *
- *   1. (parity)     The DuckDb and GraphDb hashes match each other and
- *                   the original fixture hash — i.e. `[]` round-trips
- *                   byte-identically across both backends through the
- *                   native TEXT[] / STRING[] columns.
- *   2. (difference) The hash of this fixture differs from the hash of
- *                   the equivalent fixture without the `keywords` /
- *                   `responseKeys` keys — i.e. `[]` is not silently
- *                   equivalent to absent. That assertion runs in the
- *                   accompanying "absent-keys" test below.
- *
- * This is the graphHash content-shape change tripwire: writer + reader
- * on both adapters must preserve the `[]` vs `undefined` distinction
- * or one of the two assertions will fail.
- */
-function buildMediumWithEmptyKeywordsFixture(): KnowledgeGraph {
-  const g = new KnowledgeGraph();
-  const file = makeNodeId("File", "src/api.ts", "api.ts");
-  g.addNode({ id: file, kind: "File", name: "api.ts", filePath: "src/api.ts" });
-
-  // Community node with explicit empty `keywords`. The two ownership-drift
-  // / truck-factor fields are intentionally absent so canonical-JSON only
-  // has to carry `keywords: []` as the load-bearing distinguisher.
-  const communityId = makeNodeId("Community", "<global>", "auth-community");
-  g.addNode({
-    id: communityId,
-    kind: "Community",
-    name: "auth-community",
-    filePath: "<global>",
-    inferredLabel: "auth",
-    symbolCount: 0,
-    cohesion: 1.0,
-    keywords: [],
-  });
-
-  // Route node with explicit empty `responseKeys`.
-  const routeId = makeNodeId("Route", "src/api.ts", "GET /health");
-  g.addNode({
-    id: routeId,
-    kind: "Route",
-    name: "GET /health",
-    filePath: "src/api.ts",
-    url: "/health",
-    method: "GET",
-    responseKeys: [],
-  });
-
-  g.addEdge({ from: file, to: routeId, type: "DEFINES", confidence: 1.0 });
-  return g;
-}
-
-/**
- * Companion fixture for the empty-collection difference assertion.
- * Identical to {@link buildMediumWithEmptyKeywordsFixture} except both
- * `keywords` and `responseKeys` are absent (not `[]`). The accompanying
- * test below asserts the resulting `graphHash` differs from the
- * empty-array variant — proving the writer + readers preserve the
- * `[]`-vs-absent distinction end-to-end (rather than silently coalescing
- * both to absent).
- */
-function buildMediumWithoutKeywordsFixture(): KnowledgeGraph {
-  const g = new KnowledgeGraph();
-  const file = makeNodeId("File", "src/api.ts", "api.ts");
-  g.addNode({ id: file, kind: "File", name: "api.ts", filePath: "src/api.ts" });
-
-  const communityId = makeNodeId("Community", "<global>", "auth-community");
-  g.addNode({
-    id: communityId,
-    kind: "Community",
-    name: "auth-community",
-    filePath: "<global>",
-    inferredLabel: "auth",
-    symbolCount: 0,
-    cohesion: 1.0,
-    // keywords intentionally absent.
-  });
-
-  const routeId = makeNodeId("Route", "src/api.ts", "GET /health");
-  g.addNode({
-    id: routeId,
-    kind: "Route",
-    name: "GET /health",
-    filePath: "src/api.ts",
-    url: "/health",
-    method: "GET",
-    // responseKeys intentionally absent.
-  });
-
-  g.addEdge({ from: file, to: routeId, type: "DEFINES", confidence: 1.0 });
-  return g;
-}
-
-/**
- * Repo fixture: a RepoNode exercising every field — populated +
- * explicit-null variants of `originUrl` / `defaultBranch` / `group`, and
- * a non-empty `languageStats` record. The fixture must round-trip
- * through both stores with matching graphHash, proving the new Repo
- * columns carry their payload losslessly.
- */
-function buildRepoFixture(): KnowledgeGraph {
-  const g = new KnowledgeGraph();
-  const fileA = makeNodeId("File", "src/a.ts", "a.ts");
-  g.addNode({ id: fileA, kind: "File", name: "a.ts", filePath: "src/a.ts" });
-
-  // Populated Repo node: every attribute carries a concrete value so the
-  // round-trip exercises each column.
-  const repoId = makeNodeId("Repo", "", "repo");
-  g.addNode({
-    id: repoId,
-    kind: "Repo",
-    name: "github.com/acme/example",
-    filePath: "",
-    originUrl: "https://github.com/acme/example.git",
-    repoUri: "github.com/acme/example",
-    defaultBranch: "main",
-    commitSha: "0123456789abcdef0123456789abcdef01234567",
-    indexTime: "2026-05-06T12:34:56Z",
-    group: "acme",
-    visibility: "private",
-    indexer: "opencodehub@0.1.0",
-    languageStats: { ts: 0.83, py: 0.14, md: 0.03 },
-  });
-  return g;
-}
-
-/**
- * Parallel RepoNode fixture with the nullable string fields explicitly set
- * to `null` — covers the "no remote" branch where originUrl is
- * absent, defaultBranch is unknown, and the repo is group-less. Empty
- * languageStats ({}) is normalised to NULL on the wire; the reader
- * reconstructs it as `{}` so canonical-JSON parity holds.
- */
-function buildRepoNullFixture(): KnowledgeGraph {
-  const g = new KnowledgeGraph();
-  const fileA = makeNodeId("File", "src/a.ts", "a.ts");
-  g.addNode({ id: fileA, kind: "File", name: "a.ts", filePath: "src/a.ts" });
-
-  const repoId = makeNodeId("Repo", "", "repo");
-  g.addNode({
-    id: repoId,
-    kind: "Repo",
-    name: "local:abcdef012345",
-    filePath: "",
-    originUrl: null,
-    repoUri: "local:abcdef012345",
-    defaultBranch: null,
-    commitSha: "0123456789abcdef0123456789abcdef01234567",
-    indexTime: "2026-05-06T12:34:56Z",
-    group: null,
-    visibility: "private",
-    indexer: "opencodehub@0.1.0",
-    languageStats: {},
-  });
-  return g;
-}
-
-// ---------------------------------------------------------------------------
-// Parity runner — opens both stores (skipping graph-db if its native binding
-// is missing) and delegates to the public-interface harness.
-// ---------------------------------------------------------------------------
-
-interface ParityCheck {
-  readonly name: string;
-  readonly fixture: KnowledgeGraph;
-}
-
-async function runParity({ name, fixture }: ParityCheck): Promise<void> {
-  const duck = new DuckDbStore(await scratchDuckPath());
-  await duck.open();
-  await duck.createSchema();
-  const stores: IGraphStore[] = [duck];
-
-  // Graph-db branch runs only when the native binding is importable — CI
-  // platforms without a prebuilt binary skip cleanly rather than fail.
-  let graphDb: GraphDbStore | undefined;
-  if (await hasGraphDbBinding()) {
-    graphDb = new GraphDbStore(await scratchGraphDbPath());
-    await graphDb.open();
-    await graphDb.createSchema();
-    stores.push(graphDb);
-  }
-
-  try {
-    await assertGraphParity(fixture, { stores, label: name });
-  } finally {
-    await duck.close();
-    if (graphDb) await graphDb.close();
-  }
-}
-
-/**
- * Duck-only parity variant used for fixtures that exercise STRING[] empty-array
- * semantics. lbug v0.16.1 cannot distinguish an empty STRING[] from NULL —
- * both are returned as `null` by the native binding — so the empty-array
- * round-trip is intentionally DuckDB-only until a future lbug version fixes
- * the binder. DuckDB TEXT[] correctly preserves `[]` vs absent.
- */
-async function runParityDuckOnly({ name, fixture }: ParityCheck): Promise<void> {
-  const duck = new DuckDbStore(await scratchDuckPath());
-  await duck.open();
-  await duck.createSchema();
-  try {
-    await assertGraphParity(fixture, { stores: [duck], label: name });
-  } finally {
-    await duck.close();
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-test("graphHash parity: small fixture (≤10 nodes, DEFINES + CALLS)", async () => {
-  await runParity({ name: "small", fixture: buildSmallFixture() });
-});
-
-test("graphHash parity: medium fixture (mixed node kinds + OWNED_BY edges)", async () => {
-  await runParity({ name: "medium", fixture: buildMediumFixture() });
-});
-
-test("graphHash parity: large fixture (≥500 nodes, 25-edge-kind sweep)", async () => {
-  await runParity({ name: "large", fixture: buildLargeFixture() });
-});
-
-test("graphHash parity: repo fixture (RepoNode with all attributes populated)", async () => {
-  await runParity({ name: "repo", fixture: buildRepoFixture() });
-});
-
-test("graphHash parity: repo fixture with explicit-null origin / branch / group", async () => {
-  await runParity({ name: "repo-null", fixture: buildRepoNullFixture() });
-});
-
-test("graphHash parity: medium-with-empty-keywords ([] vs absent)", async () => {
-  // lbug v0.16.1 cannot distinguish an empty STRING[] from NULL — both are
-  // returned as null by the native binding, so the [] vs absent distinction
-  // is lost on the graphdb round-trip. DuckDB TEXT[] preserves it correctly.
-  // This test uses the duck-only variant until lbug fixes the empty-array binder.
-  await runParityDuckOnly({
-    name: "medium-with-empty-keywords",
-    fixture: buildMediumWithEmptyKeywordsFixture(),
-  });
-});
-
-test("graphHash({keywords: []}) differs from graphHash({} — keywords absent)", async () => {
-  // Difference assertion — proves the writer + readers actually preserve
-  // the `[]`-vs-absent distinction. If a future regression silently
-  // coalesces `[]` back to absent, this test fires before the
-  // medium-with-empty-keywords parity test would (parity could mask the
-  // bug if BOTH adapters dropped `[]` symmetrically).
-  const withEmpty = graphHash(buildMediumWithEmptyKeywordsFixture());
-  const without = graphHash(buildMediumWithoutKeywordsFixture());
-  if (withEmpty === without) {
-    throw new Error(
-      "Regression: graphHash treats `keywords: []` and absent `keywords` as equivalent. " +
-        "Check `stringArrayOrNull` in column-encode.ts and the symmetric readers in " +
-        "duckdb-adapter.ts / graphdb-adapter.ts / analyze.ts.",
-    );
-  }
-});
diff --git a/packages/storage/src/graphdb-adapter.test.ts b/packages/storage/src/graphdb-adapter.test.ts
index 0cc7883c..bc9f226d 100644
--- a/packages/storage/src/graphdb-adapter.test.ts
+++ b/packages/storage/src/graphdb-adapter.test.ts
@@ -6,7 +6,7 @@ import { test } from "node:test";
 import { type GraphNode, KnowledgeGraph, makeNodeId, type NodeId } from "@opencodehub/core-types";
 import { assertReadOnlyCypher } from "./cypher-guard.js";
 import { GraphDbBindingError, GraphDbStore, NotImplementedError } from "./graphdb-adapter.js";
-import { openStore, resolveStoreBackend } from "./index.js";
+import { openStore } from "./index.js";
 import { assertIGraphStoreConformance } from "./test-utils/conformance.js";
 
 async function scratchDbPath(): Promise<string> {
@@ -182,56 +182,18 @@ test("open surfaces GraphDbBindingError when native binding absent", async () =>
 });
 
 // ---------------------------------------------------------------------------
-// Factory + env var resolution
+// Factory
 // ---------------------------------------------------------------------------
 
-test("resolveStoreBackend defaults to duck when env unset", () => {
-  assert.equal(resolveStoreBackend(undefined, {}), "duck");
-  assert.equal(resolveStoreBackend("auto", {}), "duck");
-});
-
-test("resolveStoreBackend respects explicit backend over env", () => {
-  assert.equal(resolveStoreBackend("duck", { CODEHUB_STORE: "lbug" }), "duck");
-  assert.equal(resolveStoreBackend("lbug", { CODEHUB_STORE: "duck" }), "lbug");
-});
-
-test("resolveStoreBackend reads CODEHUB_STORE env under auto", () => {
-  assert.equal(resolveStoreBackend("auto", { CODEHUB_STORE: "lbug" }), "lbug");
-  assert.equal(resolveStoreBackend("auto", { CODEHUB_STORE: "duck" }), "duck");
-});
-
-test("resolveStoreBackend rejects unknown CODEHUB_STORE values", () => {
-  assert.throws(
-    () => resolveStoreBackend("auto", { CODEHUB_STORE: "sqlite" }),
-    /Invalid CODEHUB_STORE/,
-  );
-});
-
-test("openStore composes a DuckDbStore graph + temporal pair when backend=duck", async () => {
-  const store = await openStore({ path: ":memory:", backend: "duck" });
-  // The duck backend wires BOTH views to the same DuckDbStore instance.
-  // Identity check — not just constructor-name — pins the single-
-  // connection invariant.
-  assert.equal(store.backend, "duck");
-  assert.equal(store.graph.constructor.name, "DuckDbStore");
-  assert.equal(store.temporal.constructor.name, "DuckDbStore");
-  assert.equal(store.graph as unknown, store.temporal as unknown);
-  assert.equal(store.graphFile, ":memory:");
-  assert.equal(store.temporalFile, ":memory:");
-  assert.equal(typeof store.close, "function");
-});
-
-test("openStore composes GraphDbStore + DuckDbStore pair when backend=lbug", async () => {
-  // The graph file is renamed to `graph.lbug` and the temporal file is
-  // its sibling `temporal.duckdb` inside the same directory, regardless
-  // of the legacy filename the caller supplies (typically
-  // `<repo>/.codehub/graph.duckdb`).
-  const store = await openStore({ path: "/tmp/och-test/graph.duckdb", backend: "lbug" });
-  assert.equal(store.backend, "lbug");
+test("openStore composes GraphDbStore + DuckDbStore pair", async () => {
+  // The graph file is canonicalized to `graph.lbug` and the temporal file
+  // is its sibling `temporal.duckdb` inside the same directory.
+  const store = await openStore({ path: "/tmp/och-test/.codehub/graph.lbug" });
   assert.equal(store.graph.constructor.name, "GraphDbStore");
   assert.equal(store.temporal.constructor.name, "DuckDbStore");
-  assert.equal(store.graphFile, "/tmp/och-test/graph.lbug");
-  assert.equal(store.temporalFile, "/tmp/och-test/temporal.duckdb");
+  assert.equal(store.graphFile, "/tmp/och-test/.codehub/graph.lbug");
+  assert.equal(store.temporalFile, "/tmp/och-test/.codehub/temporal.duckdb");
+  assert.equal(typeof store.close, "function");
 });
 
 // ---------------------------------------------------------------------------
@@ -1115,68 +1077,6 @@ test("listNodes() rehydrates Operation method/path symmetrically (graph-db)", as
   }
 });
 
-// ---------------------------------------------------------------------------
-// Cross-adapter parity — DuckStore + GraphDbStore must agree byte-for-byte
-// on the same fixture. This is the M5 BOM safety net: if listNodes
-// diverges, downstream packHash diverges, and reproducible builds break.
-// ---------------------------------------------------------------------------
-
-test("listNodes() cross-adapter parity: DuckStore ≡ GraphDbStore on the shared fixture", async () => {
-  if (!(await hasNativeBinding())) {
-    assert.ok(true, "native binding unavailable — skipping cross-adapter parity");
-    return;
-  }
-  // Lazy-import DuckDbStore so the suite still loads on graph-db-only builds
-  // (e.g. when the storage package is consumed by a slim runtime that
-  // pruned @duckdb/node-api). The native binding for DuckDB is already a
-  // peer dependency of this package so the import always resolves in CI.
-  const { DuckDbStore } = await import("./duckdb-adapter.js");
-  const { canonicalJson } = await import("@opencodehub/core-types");
-
-  const fixture = buildListNodesFixture();
-
-  const duckPath = join(
-    await mkdtemp(join(tmpdir(), "och-listnodes-parity-duck-")),
-    "graph.duckdb",
-  );
-  const duck = new DuckDbStore(duckPath);
-  await duck.open();
-  await duck.createSchema();
-  await duck.bulkLoad(fixture);
-  const duckNodes = await duck.listNodes();
-  await duck.close();
-
-  const graphdb = new GraphDbStore(await scratchDbPath());
-  await graphdb.open();
-  await graphdb.createSchema();
-  await graphdb.bulkLoad(fixture);
-  const graphNodes = await graphdb.listNodes();
-  await graphdb.close();
-
-  // Both backends must return the same number of rows in the same order.
-  assert.equal(graphNodes.length, duckNodes.length, "row count parity");
-  assert.deepEqual(
-    graphNodes.map((n) => n.id),
-    duckNodes.map((n) => n.id),
-    "id ordering parity",
-  );
-
-  // Every kind+id pair must match, plus the load-bearing wider columns
-  // for Dependency / Repo / Operation. Compare via canonicalJson so key
-  // ordering / undefined drops are consistent.
-  for (let i = 0; i < duckNodes.length; i += 1) {
-    const duckNode = duckNodes[i] as GraphNode;
-    const graphNode = graphNodes[i] as GraphNode;
-    assert.equal(graphNode.id, duckNode.id, `id parity at index ${i}`);
-    assert.equal(graphNode.kind, duckNode.kind, `kind parity at ${duckNode.id}`);
-    assert.equal(
-      canonicalJson(graphNode),
-      canonicalJson(duckNode),
-      `byte parity at ${duckNode.id}`,
-    );
-  }
-});
-
 // ---------------------------------------------------------------------------
 // v1.0 community-adapter conformance suite
 //
diff --git a/packages/storage/src/graphdb-adapter.ts b/packages/storage/src/graphdb-adapter.ts
index 701af3d2..a03fe032 100644
--- a/packages/storage/src/graphdb-adapter.ts
+++ b/packages/storage/src/graphdb-adapter.ts
@@ -3,7 +3,7 @@
  *
  * This adapter is the second implementation behind the `IGraphStore` seam.
  * DuckDbStore remains the default; this file ships the full lifecycle +
- * bulk-load surface so `CODEHUB_STORE=lbug` can already drive a
+ * bulk-load surface so the lbug graph backend already drives a
  * round-trip-clean graph write.
  *
  * Design notes:
@@ -105,8 +105,9 @@ export class GraphDbBindingError extends Error {
   constructor(cause: unknown) {
     const detail = cause instanceof Error ? cause.message : String(cause);
     super(
-      "@ladybugdb/core native binding unavailable on this platform; " +
-        `use CODEHUB_STORE=duck. Underlying cause: ${detail}`,
+      "@ladybugdb/core native binding unavailable on this platform. " +
+        `OpenCodeHub requires the lbug graph backend; install or rebuild ` +
+        `@ladybugdb/core for this platform. Underlying cause: ${detail}`,
     );
     this.name = "GraphDbBindingError";
   }
@@ -123,8 +124,7 @@ export class GraphDbBindingError extends Error {
 // prepared statement parameter list.
 // ---------------------------------------------------------------------------
 
-/** Edge rel-table property columns. Matches graphdb-schema.ts. */
-const EDGE_COLUMNS: readonly string[] = ["id", "confidence", "reason", "step"];
+// Edge columns are encoded inline in edgeToCsvLine() — no separate constant needed.
 
 /**
  * Column layout for the `Embedding` node table. Matches graphdb-schema.ts.
@@ -164,40 +164,301 @@ export const ROUND_TRIP_COLUMN_MAP: readonly (readonly [
 ];
 
 // ---------------------------------------------------------------------------
-// Cypher template builders — amortising the string work across a full bulk
-// load. Closed over NODE_COLUMNS/EDGE_COLUMNS so any column rename is
-// caught at compile time.
+// COPY FROM (subquery) bulk insert
 // ---------------------------------------------------------------------------
+//
+// lbug v0.16.1 infers struct-field types per-row from JS values: integer-
+// valued numbers (Number.isInteger) → INT64, others → DOUBLE. A
+// `confidence=1.0` edge binds as INT64 and round-trips as garbage from a
+// DOUBLE column.
+//
+// The fix: COPY <Table> FROM (UNWIND $rows AS r RETURN ...) where numeric
+// columns use CAST(r.col AS <DDLtype>) and the raw values are passed as
+// strings. The COPY FROM path resolves types from the pre-defined table
+// schema, CAST converts the string to the correct type, and per-row
+// inference never runs on numerics.
+//
+// No temp files required — rows travel as a prepared-statement parameter.
+// ---------------------------------------------------------------------------
+
+/**
+ * Column DDL type tags used to decide how to encode each value in the
+ * UNWIND row object and whether to wrap its RETURN expression in CAST.
+ * Must stay in the same order as NODE_COLUMNS.
+ */
+type ColKind = "str" | "int" | "double" | "bool" | "strarray";
+
+const NODE_COL_KINDS: readonly ColKind[] = (() => {
+  const map: Record<string, ColKind> = {
+    start_line: "int",
+    end_line: "int",
+    parameter_count: "int",
+    step_count: "int",
+    level: "int",
+    symbol_count: "int",
+    cyclomatic_complexity: "int",
+    nesting_depth: "int",
+    nloc: "int",
+    truck_factor: "int",
+    is_exported: "bool",
+    is_orphan: "bool",
+    cohesion: "double",
+    coverage_percent: "double",
+    halstead_volume: "double",
+    ownership_drift_30d: "double",
+    ownership_drift_90d: "double",
+    ownership_drift_365d: "double",
+    keywords: "strarray",
+    response_keys: "strarray",
+  };
+  return NODE_COLUMNS.map((col) => map[col] ?? "str");
+})();
+
+/**
+ * Build the `COPY CodeNode FROM (UNWIND $rows AS r RETURN ...)` statement.
+ * Numeric columns (INT32, DOUBLE) use CAST(r.col AS <type>) so that string-
+ * encoded values (e.g. "1", "0.9") reach the correct column type regardless
+ * of how the JS binding inferred the struct-field type. Non-numeric columns
+ * project directly as `r.col`.
+ */
+function buildNodeCopySubquery(): string {
+  const returnCols = NODE_COLUMNS.map((col, i) => {
+    switch (NODE_COL_KINDS[i]) {
+      case "int":
+        return `CAST(r.${col} AS INT32)`;
+      case "double":
+        return `CAST(r.${col} AS DOUBLE)`;
+      default:
+        return `r.${col}`;
+    }
+  }).join(", ");
+  // WITH r WHERE filters out the type-seeding sentinel row (see NODE_SENTINEL_ID).
+  return (
+    `COPY CodeNode FROM (UNWIND $rows AS r ` +
+    `WITH r WHERE r.id <> '${NODE_SENTINEL_ID}' ` +
+    `RETURN ${returnCols})`
+  );
+}
+
+/**
+ * Sentinel id prepended to every UNWIND batch. Row 0 of `$rows` seeds the
+ * struct-field type for every column. When row 0 has a null field, the binder
+ * infers ANY for that field's type and fails with "Trying to create a vector
+ * with ANY type". The sentinel carries a concrete non-null value for every
+ * column, and the `WITH r WHERE r.id <> NODE_SENTINEL_ID` clause in the
+ * COPY subquery filters it out before any row lands in storage.
+ */
+const NODE_SENTINEL_ID = "__OCH_SENTINEL__";
+const EDGE_SENTINEL_ID = "__OCH_EDGE_SENTINEL__";
+
+/** Pre-built node copy statement (constant — column list never changes). */
+const NODE_COPY_SUBQUERY = buildNodeCopySubquery();
+
+function buildEdgeCopySubquery(kind: string): string {
+  // IGNORE_ERRORS=true skips rows where the FROM/TO node lookup fails — this
+  // handles the type-seeding sentinel row whose from/to point to a
+  // non-existent CodeNode. Real rows should always have valid endpoints; if
+  // they don't, the edge is silently dropped (same behaviour as the old
+  // per-row path which would throw on MATCH failure).
+  return (
+    // Row struct fields use `src`/`dst` instead of `from`/`to` because FROM
+    // and TO are Cypher keywords — using them as `r.from`/`r.to` is
+    // ambiguous and silently causes the COPY to misinterpret columns.
+    // The COPY column list `(id, confidence, reason, step)` specifies which rel
+    // properties to populate. The RETURN uses `r.eid` (not `r.id`) for the
+    // edge id to avoid lbug misinterpreting it as a CodeNode PK lookup: lbug
+    // treats a RETURN column named `id` as a node-PK reference when it matches
+    // the referenced node table's primary key column name. Using a different
+    // alias breaks the false match while the positional column list maps it to
+    // the rel's `id STRING` property.
+    `COPY ${kind}(id, confidence, reason, step) FROM ` +
+    `(UNWIND $rows AS r WITH r WHERE r.eid <> '${EDGE_SENTINEL_ID}' ` +
+    `RETURN r.src, r.dst, r.eid, CAST(r.confidence AS DOUBLE), r.reason, CAST(r.step AS INT32))`
+  );
+}
 
-function buildNodeCreateCypher(): string {
-  const propPairs = NODE_COLUMNS.map((col, i) => `${col}: $p${i + 1}`).join(", ");
-  return `CREATE (n:CodeNode {${propPairs}})`;
+/**
+ * Encode a GraphNode column value for the UNWIND parameter object.
+ * Numeric columns are encoded as strings so lbug's binder does not infer
+ * INT64 for integer-valued numbers; CAST in the RETURN expression then
+ * converts to the correct DDL type. All other values pass through as-is.
+ */
+function encodeNodeCol(v: unknown, kind: ColKind): unknown {
+  // strarray must never be null — lbug infers LIST(ANY) from a null field and
+  // fails with "Trying to create a vector with ANY type". Check before the
+  // null short-circuit so absent arrays become [] rather than null.
+  if (kind === "strarray") {
+    if (!Array.isArray(v)) return [] as string[];
+    return (v as unknown[]).filter((x) => typeof x === "string") as string[];
+  }
+  if (v === null || v === undefined) return null;
+  switch (kind) {
+    case "int":
+      return typeof v === "number" && Number.isFinite(v) ? String(Math.trunc(v)) : null;
+    case "double":
+      return typeof v === "number" && Number.isFinite(v) ? String(v) : null;
+    case "bool":
+      return typeof v === "boolean" ? v : null;
+    default:
+      return typeof v === "string" ? v : String(v);
+  }
 }
 
-function buildNodeMergeCypher(): string {
-  // MERGE by primary key; SET every non-id field on both the create and
-  // match branches so the row's state is always the caller's newest view.
-  const setClauses = NODE_COLUMNS.slice(1)
-    .map((col, i) => `n.${col} = $p${i + 2}`)
-    .join(", ");
-  return `MERGE (n:CodeNode {id: $p1}) SET ${setClauses}`;
+/**
+ * Build the type-seeding sentinel row for a node batch. Every column gets a
+ * concrete non-null value matching its DDL type so lbug's binder can resolve
+ * every struct field at prepare time. The WITH/WHERE clause in the COPY
+ * subquery filters it out before any storage write.
+ *
+ * STRING[] columns get a single-element seed (`["__sentinel__"]`) — lbug's
+ * struct-field inference looks at the FIRST row's array contents to fix
+ * the LIST element type. An empty-array sentinel forces LIST(ANY) and the
+ * binder later throws "Trying to create a vector with ANY type" when a
+ * data row supplies a string. The seed value never reaches storage; the
+ * sentinel row is filtered before COPY writes.
+ */
+function buildNodeSentinel(): Record<string, unknown> {
+  const sentinel: Record<string, unknown> = {};
+  for (let i = 0; i < NODE_COLUMNS.length; i++) {
+    const col = NODE_COLUMNS[i] as string;
+    switch (NODE_COL_KINDS[i]) {
+      case "int":
+        sentinel[col] = "0";
+        break;
+      case "double":
+        sentinel[col] = "0.0";
+        break;
+      case "bool":
+        sentinel[col] = false;
+        break;
+      case "strarray":
+        sentinel[col] = ["__sentinel__"] as string[];
+        break;
+      default:
+        sentinel[col] = "";
+        break;
+    }
+  }
+  sentinel["id"] = NODE_SENTINEL_ID;
+  return sentinel;
 }
 
-function buildEdgeCreateCypher(kind: string): string {
-  // p1 = from id, p2 = to id, p3..p6 = EDGE_COLUMNS.
-  const propPairs = EDGE_COLUMNS.map((col, i) => `${col}: $p${i + 3}`).join(", ");
-  return `MATCH (a:CodeNode {id: $p1}), (b:CodeNode {id: $p2}) CREATE (a)-[:${kind} {${propPairs}}]->(b)`;
+/** Pre-built node sentinel row (constant — same shape for every batch). */
+const NODE_SENTINEL_ROW = buildNodeSentinel();
+
+/**
+ * Walk the edge set and synthesize a stub `Repository` node for every
+ * `from`/`to` id that doesn't appear in the node set. The pipeline's
+ * fetches phase (and any future cross-repo edge that points at a
+ * not-yet-resolved target) emits ids like `fetches:unresolved:GET:/users/1`
+ * that intentionally have no corresponding node — the URL template lives
+ * on the edge's `reason` for downstream lookup. lbug's COPY rejects
+ * those edges because the to-node primary key is missing; DuckDB used to
+ * accept them silently. Synthesize a minimal placeholder so the bulk
+ * load completes, with the original id preserved for round-trip.
+ */
+function synthesizePlaceholderNodes(
+  nodes: readonly GraphNode[],
+  edges: readonly { readonly from: NodeId; readonly to: NodeId }[],
+): GraphNode[] {
+  const known = new Set<string>();
+  for (const n of nodes) known.add(n.id as string);
+  const missing = new Set<string>();
+  for (const e of edges) {
+    if (!known.has(e.from as string)) missing.add(e.from as string);
+    if (!known.has(e.to as string)) missing.add(e.to as string);
+  }
+  if (missing.size === 0) return [];
+  const out: GraphNode[] = [];
+  for (const id of missing) {
+    // Route is the right kind for unresolved-fetch placeholders (the
+    // edge that referenced it was a FETCHES targeting an HTTP endpoint).
+    // For other orphan id shapes the kind is still cosmetic — the only
+    // load-bearing requirement is that the COPY finds a primary key.
+    out.push({
+      id: id as NodeId,
+      kind: "Route",
+      name: id,
+      filePath: "<placeholder>",
+      url: id,
+    } as GraphNode);
+  }
+  return out;
 }
 
-function buildEdgeMergeCypher(kind: string): string {
-  // Pattern-match then SET. Matching by endpoints + label collapses duplicate
-  // edges that share (from, to, type); a second edge with the same triple
-  // updates the same rel's properties rather than adding a parallel edge.
-  const setClauses = EDGE_COLUMNS.map((col, i) => `r.${col} = $p${i + 3}`).join(", ");
-  return (
-    `MATCH (a:CodeNode {id: $p1}), (b:CodeNode {id: $p2}) ` +
-    `MERGE (a)-[r:${kind}]->(b) SET ${setClauses}`
-  );
+/**
+ * Sentinel row for edge batches. Typed seed for every EDGE column so
+ * lbug's binder resolves struct fields even when the real batch has nulls.
+ */
+const EDGE_SENTINEL_ROW: Record<string, unknown> = {
+  eid: EDGE_SENTINEL_ID,
+  src: "",
+  dst: "",
+  confidence: "0.0",
+  reason: null,
+  step: null,
+};
+
+async function bulkInsertNodes(pool: GraphDbPool, nodes: readonly GraphNode[]): Promise<void> {
+  if (nodes.length === 0) return;
+  const rows: Record<string, unknown>[] = [NODE_SENTINEL_ROW];
+  for (const node of nodes) {
+    const cols = nodeToColumns(node);
+    const row: Record<string, unknown> = {};
+    for (let i = 0; i < NODE_COLUMNS.length; i++) {
+      const col = NODE_COLUMNS[i] as string;
+      const kind = NODE_COL_KINDS[i] as ColKind;
+      row[col] = encodeNodeCol(cols[col], kind);
+    }
+    rows.push(row);
+  }
+  await pool.execWrite(NODE_COPY_SUBQUERY, { rows });
+}
+
+async function mergeNodes(pool: GraphDbPool, nodes: readonly GraphNode[]): Promise<void> {
+  if (nodes.length === 0) return;
+  for (const n of nodes) {
+    await pool.query(`MATCH (n:CodeNode {id: $p1}) DETACH DELETE n`, [n.id]);
+  }
+  await bulkInsertNodes(pool, nodes);
+}
+
+async function bulkInsertEdges(
+  pool: GraphDbPool,
+  kind: string,
+  edges: readonly EdgeRow[],
+): Promise<void> {
+  if (edges.length === 0) return;
+  const rows: Record<string, unknown>[] = [EDGE_SENTINEL_ROW];
+  for (const e of edges) {
+    rows.push({
+      eid: e.id,
+      src: e.from,
+      dst: e.to,
+      confidence:
+        typeof e.confidence === "number" && Number.isFinite(e.confidence)
+          ? String(e.confidence)
+          : null,
+      reason: e.reason ?? null,
+      step:
+        e.step !== undefined && typeof e.step === "number" && Number.isFinite(e.step)
+          ? String(e.step)
+          : null,
+    });
+  }
+  await pool.execWrite(buildEdgeCopySubquery(kind), { rows });
+}
+
+async function mergeEdges(
+  pool: GraphDbPool,
+  kind: string,
+  edges: readonly EdgeRow[],
+): Promise<void> {
+  if (edges.length === 0) return;
+  for (const e of edges) {
+    await pool.query(`MATCH ()-[r:${kind} {id: $p1}]->() DELETE r`, [e.id]);
+  }
+  await bulkInsertEdges(pool, kind, edges);
 }
 
 function buildEmbeddingCreateCypher(): string {
@@ -313,25 +574,49 @@ export class GraphDbStore implements IGraphStore {
     const pool = this.requirePool();
     const started = performance.now();
     const mode = opts.mode ?? "replace";
+    // The FTS extension must be loaded on the active connection before
+    // any DELETE / DETACH DELETE on CodeNode runs. lbug builds the FTS
+    // index against the table; without the extension loaded, deletes
+    // surface "Trying to delete from an index on table CodeNode but its
+    // extension is not loaded". Both replace-mode `truncateAll` and
+    // upsert-mode `mergeNodes` issue such deletes, so load it
+    // unconditionally up front. Failures are swallowed: the extension
+    // may not be available on the host platform, in which case the
+    // search-side codepath surfaces a clearer error from
+    // `ensureFtsExtension` later.
+    await this.ensureFtsExtension().catch(() => {});
+    const reportProgress = (
+      ev: Parameters<NonNullable<BulkLoadOptions["onProgress"]>>[0],
+    ): void => {
+      if (opts.onProgress === undefined) return;
+      try {
+        opts.onProgress(ev);
+      } catch {
+        // Progress-callback errors must never mask bulk-load failures.
+      }
+    };
 
     if (mode === "replace") {
+      reportProgress({ kind: "truncate-start", elapsedMs: performance.now() - started });
       await this.truncateAll();
+      reportProgress({ kind: "truncate-end", elapsedMs: performance.now() - started });
     }
 
     const nodes = dedupeLastById(graph.orderedNodes(), (n) => n.id);
-    await this.insertNodes(pool, nodes, mode);
-
-    // Group edges by relation type so we build one Cypher template per kind
-    // and iterate its bucket with a single parameter set. The native binding
-    // does not let us parameterize the rel label, so each kind needs its own
-    // template.
     const edges = dedupeLastById(graph.orderedEdges(), (e) => e.id);
+    // lbug's COPY enforces that every relation's from/to is a real
+    // CodeNode primary key. The pipeline emits synthetic edge targets
+    // (e.g. unresolved FETCHES placeholders carrying the URL template
+    // in `reason`) that never have a matching node. Synthesize one
+    // CodeNode per orphan id so the COPY succeeds; downstream tools
+    // recognise these by their well-known id prefix.
+    const synthetic = synthesizePlaceholderNodes(nodes, edges);
+    const allNodes = synthetic.length > 0 ? [...nodes, ...synthetic] : nodes;
+    await this.insertNodes(pool, allNodes, mode, reportProgress, started);
+
     const byKind = new Map<RelationType, EdgeRow[]>();
     for (const e of edges) {
       const bucket = byKind.get(e.type) ?? [];
-      // `exactOptionalPropertyTypes` rejects explicit `undefined` on an
-      // optional property — spread the narrow fields then conditionally
-      // attach `reason`/`step` only when they carry a real value.
       const row: EdgeRow = {
         id: e.id,
         from: e.from,
@@ -344,10 +629,40 @@ export class GraphDbStore implements IGraphStore {
       bucket.push(row);
       byKind.set(e.type, bucket);
     }
+    if (edges.length > 0) {
+      reportProgress({
+        kind: "edges-start",
+        total: edges.length,
+        elapsedMs: performance.now() - started,
+      });
+    }
+    let edgesDone = 0;
     for (const [kind, bucket] of byKind) {
-      await this.insertEdgesForKind(pool, kind, bucket, mode);
+      await this.insertEdgesForKind(pool, kind, bucket, mode, reportProgress, () => {
+        edgesDone += bucket.length;
+        return { done: edgesDone, total: edges.length, elapsedMs: performance.now() - started };
+      });
+    }
+    if (edges.length > 0) {
+      reportProgress({
+        kind: "edges-end",
+        done: edges.length,
+        total: edges.length,
+        elapsedMs: performance.now() - started,
+      });
     }
 
+    // Build the search-side indexes here so subsequent read-only opens
+    // can query without triggering writes. lbug rejects
+    // `CALL CREATE_FTS_INDEX` / `CALL CREATE_VECTOR_INDEX` on a readOnly
+    // Database — and `ensureFtsIndex` / `ensureVectorIndex` correctly
+    // no-op in that mode. Any failure at this stage is non-fatal: the
+    // FTS / VECTOR extension may not be available on the host platform,
+    // in which case search/vectorSearch will surface a clearer error
+    // from the extension load path the next time they're called.
+    await this.ensureFtsExtension().catch(() => {});
+    await this.ensureFtsIndex().catch(() => {});
+
     const durationMs = performance.now() - started;
     return {
       nodeCount: graph.nodeCount(),
@@ -372,13 +687,26 @@ export class GraphDbStore implements IGraphStore {
     pool: GraphDbPool,
     nodes: readonly GraphNode[],
     mode: "replace" | "upsert",
+    reportProgress: (ev: Parameters<NonNullable<BulkLoadOptions["onProgress"]>>[0]) => void,
+    bulkStartedAt: number,
   ): Promise<void> {
     if (nodes.length === 0) return;
-    const cypher = mode === "upsert" ? buildNodeMergeCypher() : buildNodeCreateCypher();
-    for (const node of nodes) {
-      const params = nodeToParams(node);
-      await pool.query(cypher, params);
+    reportProgress({
+      kind: "nodes-start",
+      total: nodes.length,
+      elapsedMs: performance.now() - bulkStartedAt,
+    });
+    if (mode === "upsert") {
+      await mergeNodes(pool, nodes);
+    } else {
+      await bulkInsertNodes(pool, nodes);
     }
+    reportProgress({
+      kind: "nodes-end",
+      done: nodes.length,
+      total: nodes.length,
+      elapsedMs: performance.now() - bulkStartedAt,
+    });
   }
 
   private async insertEdgesForKind(
@@ -386,26 +714,17 @@ export class GraphDbStore implements IGraphStore {
     kind: string,
     edges: readonly EdgeRow[],
     mode: "replace" | "upsert",
+    reportProgress: (ev: Parameters<NonNullable<BulkLoadOptions["onProgress"]>>[0]) => void,
+    cumulative: () => { done: number; total: number; elapsedMs: number },
   ): Promise<void> {
     if (edges.length === 0) return;
-    const cypher = mode === "upsert" ? buildEdgeMergeCypher(kind) : buildEdgeCreateCypher(kind);
-    for (const e of edges) {
-      // `step` is preserved as NULL when the source edge omits it so the
-      // round-trip reader can distinguish "intentionally absent" from
-      // "explicit zero". DuckDbStore stores 0 in both cases because the
-      // column is NOT NULL; the graph-db schema declares it as nullable
-      // INT32 and the canonical-JSON hash stays stable across backends as
-      // long as both adapters agree on the sentinel.
-      const params: SqlParam[] = [
-        e.from,
-        e.to,
-        e.id,
-        e.confidence,
-        e.reason ?? null,
-        e.step ?? null,
-      ];
-      await pool.query(cypher, params);
+    if (mode === "upsert") {
+      await mergeEdges(pool, kind, edges);
+    } else {
+      await bulkInsertEdges(pool, kind, edges);
     }
+    const c = cumulative();
+    reportProgress({ kind: "edges-batch", relType: kind, ...c });
   }
 
   // --------------------------------------------------------------------------
@@ -1504,6 +1823,13 @@ export class GraphDbStore implements IGraphStore {
 
   private async ensureFtsIndex(): Promise<void> {
     if (this.ftsIndexBuilt) return;
+    // Read-only opens cannot run `CALL CREATE_FTS_INDEX` (lbug rejects
+    // writes against a readOnly Database). The index is built at
+    // bulk-load time on the write path; readers just query it.
+    if (this.readOnly) {
+      this.ftsIndexBuilt = true;
+      return;
+    }
     const pool = this.requirePool();
     // `CALL CREATE_FTS_INDEX` fails if the index already exists; swallow
     // that specific failure so the call is idempotent from the adapter's
@@ -1521,6 +1847,10 @@ export class GraphDbStore implements IGraphStore {
 
   private async ensureVectorIndex(): Promise<void> {
     if (this.vectorIndexBuilt) return;
+    if (this.readOnly) {
+      this.vectorIndexBuilt = true;
+      return;
+    }
     const pool = this.requirePool();
     try {
       await pool.query("CALL CREATE_VECTOR_INDEX('Embedding', 'och_vec', 'vector')");
@@ -1566,20 +1896,6 @@ interface EdgeRow {
   readonly step?: number;
 }
 
-/**
- * Convert a GraphNode into the positional parameter list matching
- * `NODE_COLUMNS` (now exported from `./column-encode.ts`). The body is a
- * thin projection from the canonical column-keyed map produced by
- * {@link nodeToColumns} into the positional shape the native binding
- * expects. `null` is used for any field the node does not carry. Arrays
- * are passed through as `string[]` — the native binding accepts a JS array
- * directly for the STRING[] column type.
- */
-function nodeToParams(node: GraphNode): readonly SqlParam[] {
-  const cols = nodeToColumns(node);
-  return NODE_COLUMNS.map((key) => cols[key] as SqlParam);
-}
-
 /**
  * Rewrite a DuckDB-style whereClause (using `?` placeholders and `n.*`
  * column references) into Cypher (using `$pN` placeholders and `node.*`).
diff --git a/packages/storage/src/graphdb-pool.ts b/packages/storage/src/graphdb-pool.ts
index e4b1a15a..e632d3ba 100644
--- a/packages/storage/src/graphdb-pool.ts
+++ b/packages/storage/src/graphdb-pool.ts
@@ -89,6 +89,7 @@ export interface NativeBinding {
     bufferManagerSize?: number,
     enableCompression?: boolean,
     readOnly?: boolean,
+    maxDBSize?: number,
   ) => NativeDatabase;
   Connection: new (db: NativeDatabase) => NativeConnection;
 }
@@ -108,6 +109,27 @@ export interface GraphDbPoolConfig {
   readonly idleSweepIntervalMs?: number;
   /** Open the database read-only. Default false. */
   readonly readOnly?: boolean;
+  /**
+   * Buffer manager (temp-page region) size in bytes. lbug's native default is
+   * `min(systemMemory, maxDBSize) * 0.8` — easily 50+ GiB on a beefy host. We
+   * cap at 256 MiB by default so the in-memory page pool stays bounded across
+   * many concurrent test DBs without affecting on-disk capacity. Production
+   * callers can pass a larger value for analyze-time bulk loads.
+   */
+  readonly bufferManagerBytes?: number;
+  /**
+   * Maximum on-disk database size (and the size of the per-Database virtual
+   * mmap). lbug's native default is `1 << 43` = 8 TiB per Database, which
+   * exhausts the 47-bit user virtual address space (~128 TiB) after ~16
+   * concurrent instances and surfaces as "Buffer manager exception: Mmap
+   * for size 8796093022208 failed". Must be a power of 2.
+   *
+   * Default 16 GiB — comfortably larger than any plausible OCH graph
+   * artifact (~few GiB at the high end), drops per-Database virtual reserve
+   * 512×, and lets the test suite spin up hundreds of pools without
+   * address-space pressure.
+   */
+  readonly maxDbBytes?: number;
   /**
    * Injected native binding. Defaults to `require("@ladybugdb/core")`
    * via dynamic import on first `open()`. Tests inject a fake.
@@ -122,6 +144,20 @@ export const DEFAULT_WAITER_TIMEOUT_MS = 15_000;
 export const DEFAULT_QUERY_TIMEOUT_MS = 30_000;
 export const DEFAULT_IDLE_TIMEOUT_MS = 5 * 60 * 1000;
 export const DEFAULT_IDLE_SWEEP_INTERVAL_MS = 60_000;
+/**
+ * lbug `bufferManagerSize` cap. 2 GiB. Power of 2 not required.
+ *
+ * The buffer manager is the in-memory page cache; under-sizing it surfaces
+ * as "Buffer manager exception: Unable to allocate memory! The buffer pool
+ * is full and no memory could be freed!" the moment a single query's hot
+ * working set exceeds the cap. lbug's native default is `min(systemMem,
+ * maxDBSize) * 0.8` (≥50 GiB on a beefy host), so we cap explicitly to keep
+ * concurrent test DBs from contending for physical RAM. 2 GiB is roughly
+ * the largest BOM-body fixture × 4× headroom for vector ops.
+ */
+export const DEFAULT_BUFFER_MANAGER_BYTES = 2 * 1024 * 1024 * 1024;
+/** lbug `maxDBSize` cap. 16 GiB. MUST be a power of 2 — lbug enforces this. */
+export const DEFAULT_MAX_DB_BYTES = 16 * 1024 * 1024 * 1024;
 
 interface Waiter {
   readonly resolve: (conn: NativeConnection) => void;
@@ -268,6 +304,8 @@ export class GraphDbPool {
       idleTimeoutMs: config.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS,
       idleSweepIntervalMs: config.idleSweepIntervalMs ?? DEFAULT_IDLE_SWEEP_INTERVAL_MS,
       readOnly: config.readOnly ?? false,
+      bufferManagerBytes: config.bufferManagerBytes ?? DEFAULT_BUFFER_MANAGER_BYTES,
+      maxDbBytes: config.maxDbBytes ?? DEFAULT_MAX_DB_BYTES,
     };
     // `exactOptionalPropertyTypes` refuses explicit `undefined` on an
     // optional property — only omit-or-assign-value is allowed.
@@ -295,9 +333,10 @@ export class GraphDbPool {
       evictLruIfNeeded(this.config.maxPoolSize, this.path);
       const db = new binding.Database(
         this.path,
-        0, // bufferManagerSize — 0 means default
+        this.config.bufferManagerBytes,
         false, // enableCompression — default
         this.config.readOnly,
+        this.config.maxDbBytes,
       );
       const connections: NativeConnection[] = [];
       for (let i = 0; i < this.config.maxConnections; i += 1) {
@@ -365,6 +404,43 @@ export class GraphDbPool {
     }
   }
 
+  /**
+   * Execute a write statement that must bypass the Cypher read-only guard
+   * — used exclusively by the internal bulk-load path for
+   * `COPY <Table> FROM (UNWIND $rows ...)` calls. Not exposed on
+   * `IGraphStore`; callers outside `GraphDbStore.bulkLoad` must NOT call
+   * this method.
+   */
+  async execWrite(
+    stmt: string,
+    params?: Record<string, unknown>,
+    opts?: { readonly timeoutMs?: number },
+  ): Promise<void> {
+    const entry = this.requireEntry();
+    entry.lastUsed = Date.now();
+    const timeoutMs = opts?.timeoutMs ?? entry.config.queryTimeoutMs;
+    const conn = await this.acquire(entry);
+    try {
+      const work = (async () => {
+        if (params && Object.keys(params).length > 0) {
+          const prepared = await conn.prepare(stmt);
+          if (!prepared.isSuccess()) {
+            throw new Error(`GraphDbPool execWrite prepare failed: ${prepared.getErrorMessage()}`);
+          }
+          const res = await conn.execute(prepared, params);
+          // Drain result to surface any execution errors.
+          const result = Array.isArray(res) ? res[0] : res;
+          if (result) await result.getAll();
+        } else {
+          await conn.query(stmt);
+        }
+      })();
+      await raceWithTimeout(work, timeoutMs, "execWrite");
+    } finally {
+      this.release(entry, conn);
+    }
+  }
+
   /**
    * Acquire a connection. Exposed for callers (e.g. bulk-load paths)
    * that need to hold a connection across multiple statements.
diff --git a/packages/storage/src/index.ts b/packages/storage/src/index.ts
index 47bc0b27..d45eb5e8 100644
--- a/packages/storage/src/index.ts
+++ b/packages/storage/src/index.ts
@@ -1,5 +1,5 @@
 export { assertReadOnlyCypher, CypherGuardError } from "./cypher-guard.js";
-export { DuckDbStore, type DuckDbStoreOptions } from "./duckdb-adapter.js";
+export { classifyLicenseTier, DuckDbStore, type DuckDbStoreOptions } from "./duckdb-adapter.js";
 export {
   GraphDbBindingError,
   GraphDbStore,
@@ -13,11 +13,11 @@ export {
 } from "./graphdb-schema.js";
 export type {
   AncestorTraversalOptions,
-  BackendKind,
+  BulkLoadOptions,
+  BulkLoadProgressEvent,
   BulkLoadStats,
   CochangeLookupOptions,
   CochangeRow,
-  CochangeStore,
   ConsumerProducerEdge,
   DescendantTraversalOptions,
   EmbeddingGranularity,
@@ -41,7 +41,6 @@ export type {
   Store,
   StoreMeta,
   SymbolSummaryRow,
-  SymbolSummaryStore,
   TraverseQuery,
   TraverseResult,
   VectorQuery,
@@ -53,7 +52,7 @@ export {
   META_DIR_NAME,
   META_FILE_NAME,
   REGISTRY_FILE_NAME,
-  resolveDbPath,
+  resolveGraphPath,
   resolveMetaFilePath,
   resolveRegistryPath,
   resolveRepoMetaDir,
@@ -61,248 +60,40 @@ export {
 export { generateSchemaDDL, type SchemaOptions } from "./schema-ddl.js";
 export { assertReadOnlySql, SqlGuardError } from "./sql-guard.js";
 
-import { stat } from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
+import { dirname, join } from "node:path";
 import { DuckDbStore, type DuckDbStoreOptions } from "./duckdb-adapter.js";
 import { GraphDbStore, type GraphDbStoreOptions } from "./graphdb-adapter.js";
-import type {
-  OpenStoreOptions as ApiOpenStoreOptions,
-  BackendKind,
-  IGraphStore,
-  ITemporalStore,
-  OpenStoreResult,
-} from "./interface.js";
+import type { OpenStoreOptions as ApiOpenStoreOptions, OpenStoreResult } from "./interface.js";
 import { describeArtifacts } from "./paths.js";
 
 /**
  * Combined options accepted by {@link openStore}. Backwards-compatible
- * superset of the spec-level {@link ApiOpenStoreOptions}: keeps the
+ * superset of the spec-level {@link ApiOpenStoreOptions} that adds the
  * `duckOptions` / `graphDbOptions` adapter-specific bag so existing
- * callers (analyze CLI, ingestion harness) can continue passing through
- * the precise per-backend tuning alongside the auto-detect resolver.
+ * callers (analyze CLI, ingestion harness) can pass through precise
+ * per-backend tuning.
  */
 export interface OpenStoreOptions extends ApiOpenStoreOptions {
   readonly duckOptions?: DuckDbStoreOptions;
   readonly graphDbOptions?: GraphDbStoreOptions;
 }
 
-const ENV_VAR = "CODEHUB_STORE";
-
-/** Backends concretely implemented in-tree today. */
-type ResolvedBackend = "duck" | "lbug";
-
-/**
- * Resolve the concrete backend id from the env-only signal. Exported as
- * a sync function so unit tests can assert env-var behaviour without
- * spinning up the dynamic-import probe.
- *
- * Resolution rules (env-only):
- *   - explicit `backend === "duck" | "lbug"` → honored.
- *   - `backend === "auto"` (or `undefined`):
- *       - `CODEHUB_STORE=duck` (or unset / empty) → `"duck"` (legacy default).
- *       - `CODEHUB_STORE=lbug` → `"lbug"`.
- *       - any other value → throw.
- *
- * The async sibling {@link resolveStoreBackendAsync} adds the
- * binding-availability probe: when env is unset, it calls
- * `import("@ladybugdb/core")` and prefers `"lbug"` on success. The sync
- * resolver here intentionally returns `"duck"` for `auto+unset` because
- * the dynamic import cannot complete synchronously; callers that need
- * the auto-probe behaviour route through {@link resolveStoreBackendAsync}.
- */
-export function resolveStoreBackend(
-  backend: OpenStoreOptions["backend"],
-  env: NodeJS.ProcessEnv = process.env,
-): ResolvedBackend {
-  if (backend === "duck" || backend === "lbug") return backend;
-  if (backend !== undefined && backend !== "auto") {
-    throw new Error(
-      `openStore: backend=${JSON.stringify(backend)} is reserved for community ` +
-        `adapters and not implemented in-tree. Use "duck" or "lbug".`,
-    );
-  }
-  const raw = env[ENV_VAR];
-  if (raw === undefined || raw === "" || raw === "duck") return "duck";
-  if (raw === "lbug") return "lbug";
-  throw new Error(`Invalid ${ENV_VAR}=${JSON.stringify(raw)}; expected "duck" or "lbug".`);
-}
-
-/**
- * Module-scope cache for the `@ladybugdb/core` availability probe.
- * The probe is performed at most once per process. The cache holds the
- * in-flight promise so concurrent callers share the single import.
- */
-let _lbugProbeCache: Promise<boolean> | null = null;
-
-/** One-shot stderr-advisory guards. Reset only by re-importing this module. */
-let _lbugFallbackWarned = false;
-let _dualArtifactWarned = false;
-
-/**
- * Probe `@ladybugdb/core` availability via dynamic `import()`. The probe
- * never throws — failure (binding missing on this platform, version
- * mismatch, etc.) resolves to `false` and the caller falls back to
- * `"duck"`.
- *
- * The first invocation triggers the import and caches the resulting
- * promise; subsequent invocations return the cached promise so the
- * import runs at most once per process. Test-only callers can pass a
- * `probe` override to {@link resolveStoreBackendAsync} to bypass the
- * cache entirely.
- */
-function probeLbugBinding(): Promise<boolean> {
-  if (_lbugProbeCache === null) {
-    _lbugProbeCache = import("@ladybugdb/core").then(
-      () => true,
-      () => false,
-    );
-  }
-  return _lbugProbeCache;
-}
-
-/**
- * Test-only escape hatch: reset the probe cache + advisory guards so
- * unit tests can rerun resolution from a clean slate. Not exported on
- * the public package surface.
- *
- * @internal
- */
-export function _resetStoreResolverCache(): void {
-  _lbugProbeCache = null;
-  _lbugFallbackWarned = false;
-  _dualArtifactWarned = false;
-}
-
-/**
- * Emit a one-shot stderr advisory when running interactively or when
- * `OCH_VERBOSE=1` is set. CI runs (no TTY, no opt-in) stay quiet so the
- * default-fallback path does not pollute build logs.
- */
-function shouldEmitAdvisory(env: NodeJS.ProcessEnv = process.env): boolean {
-  if (env["OCH_VERBOSE"] === "1") return true;
-  return Boolean(process.stderr.isTTY);
-}
-
 /**
- * Async backend resolver — the graph-default entry point. Honors the
- * explicit env var first, then probes `@ladybugdb/core` when the caller
- * asked for `"auto"` and `CODEHUB_STORE` is unset.
+ * Compose paired graph + temporal artifact paths. The graph artifact is
+ * `<dir>/graph.lbug` (lbug owns this file); the temporal sidecar is
+ * `<dir>/temporal.duckdb`.
  *
- * The probe runs at most once per process via {@link probeLbugBinding};
- * subsequent calls hit the cached result. On binding failure the resolver
- * resolves to `"duck"` and emits a one-shot stderr advisory (gated by
- * TTY / `OCH_VERBOSE=1`) so CI runs stay quiet but interactive devs see
- * why the graph backend did not engage.
- *
- * @param probe - Test-only injectable probe; defaults to the cached
- *                module-scope `import("@ladybugdb/core")`.
- */
-export async function resolveStoreBackendAsync(
-  backend: OpenStoreOptions["backend"],
-  env: NodeJS.ProcessEnv = process.env,
-  probe: () => Promise<boolean> = probeLbugBinding,
-): Promise<ResolvedBackend> {
-  // Explicit backend → honored synchronously, no probe.
-  if (backend === "duck" || backend === "lbug") return backend;
-  if (backend !== undefined && backend !== "auto") {
-    throw new Error(
-      `openStore: backend=${JSON.stringify(backend)} is reserved for community ` +
-        `adapters and not implemented in-tree. Use "duck" or "lbug".`,
-    );
-  }
-  // Env var wins over the probe — explicit user intent.
-  const raw = env[ENV_VAR];
-  if (raw === "duck") return "duck";
-  if (raw === "lbug") return "lbug";
-  if (raw !== undefined && raw !== "") {
-    throw new Error(`Invalid ${ENV_VAR}=${JSON.stringify(raw)}; expected "duck" or "lbug".`);
-  }
-  // auto + unset → probe.
-  const lbugAvailable = await probe();
-  if (lbugAvailable) return "lbug";
-  if (!_lbugFallbackWarned && shouldEmitAdvisory(env)) {
-    _lbugFallbackWarned = true;
-    process.stderr.write(
-      "[opencodehub] @ladybugdb/core binding not available — falling back to DuckDB. " +
-        `Set ${ENV_VAR}=duck to silence this advisory.\n`,
-    );
-  }
-  return "duck";
-}
-
-/**
- * Dual-artifact detection — when both `graph.duckdb` and `graph.lbug`
- * exist as siblings in the same directory, prefer the newer-mtime one
- * over the resolved backend's choice. This handles the M7 transition
- * where a user re-analyzes with `CODEHUB_STORE=lbug` but the older
- * DuckDB artifact is still on disk: the newer file is the source of
- * truth, regardless of which backend the env var picked.
- *
- * Returns the (possibly overridden) resolved backend. Emits a one-shot
- * stderr advisory when an override fires.
- *
- * Pure stat call — no read of either artifact. The check is skipped
- * for `:memory:` paths (DuckDB's in-memory mode) since there is no
- * filesystem to inspect.
- */
-export async function detectDualArtifacts(
-  graphFile: string,
-  temporalFile: string,
-  backend: ResolvedBackend,
-  env: NodeJS.ProcessEnv = process.env,
-): Promise<ResolvedBackend> {
-  // In-memory or non-filesystem paths short-circuit.
-  if (graphFile === ":memory:" || temporalFile === ":memory:") return backend;
-  const dir = dirname(graphFile);
-  const duckPath = join(dir, describeArtifacts("duck").graphFile);
-  const lbugPath = join(dir, describeArtifacts("lbug").graphFile);
-  // Cheap: stat both. If either is missing the dual-artifact case does
-  // not apply.
-  const [duckStat, lbugStat] = await Promise.all([
-    stat(duckPath).catch(() => null),
-    stat(lbugPath).catch(() => null),
-  ]);
-  if (duckStat === null || lbugStat === null) return backend;
-  // Both files exist. Pick the newer mtime.
-  const winner: ResolvedBackend = duckStat.mtimeMs > lbugStat.mtimeMs ? "duck" : "lbug";
-  if (winner !== backend && !_dualArtifactWarned && shouldEmitAdvisory(env)) {
-    _dualArtifactWarned = true;
-    process.stderr.write(
-      `[opencodehub] both ${basename(duckPath)} and ${basename(lbugPath)} found in ${dir}; ` +
-        `using ${winner === "duck" ? basename(duckPath) : basename(lbugPath)} ` +
-        "(newer mtime). Remove the stale artifact to silence this advisory.\n",
-    );
-  }
-  return winner;
-}
-
-/**
- * Compose paired graph + temporal artifact paths. DuckDB-only deployments
- * collapse to a single file (the same path serves both views via one
- * connection). Graph-db pairings (`@ladybugdb/core` backend) split the
- * graph and temporal artifacts into siblings inside the same `.codehub/`
- * directory:
- *
- *   - graph artifact → `<dir>/graph.lbug` (renamed from the input filename
- *     so the on-disk extension matches the engine that owns the file).
- *   - temporal artifact → `<dir>/temporal.duckdb` (sibling DuckDB file).
- *
- * The input `path` is the legacy graph-DB file path (typically
- * `<repo>/.codehub/graph.duckdb`); we keep that contract for callers that
- * cannot yet tell the two backends apart and rewrite the filename when
- * the resolved backend is `lbug`. Filename selection is delegated to
- * {@link describeArtifacts} in `paths.ts` so two-store deployments share
- * a single source of truth.
+ * The input `path` is treated as the directory anchor — its dirname is
+ * the `<repo>/.codehub/` parent, and the canonical filenames are
+ * appended. `:memory:` is a special case for tests: both views resolve
+ * to `:memory:` and no filesystem layout applies.
  */
-function composeArtifactPaths(
-  backend: ResolvedBackend,
-  path: string,
-): { graphFile: string; temporalFile: string } {
-  if (backend === "duck") {
-    return { graphFile: path, temporalFile: path };
+function composeArtifactPaths(path: string): { graphFile: string; temporalFile: string } {
+  if (path === ":memory:") {
+    return { graphFile: ":memory:", temporalFile: ":memory:" };
   }
   const dir = dirname(path);
-  const { graphFile, temporalFile } = describeArtifacts(backend);
+  const { graphFile, temporalFile } = describeArtifacts();
   return {
     graphFile: join(dir, graphFile),
     temporalFile: join(dir, temporalFile),
@@ -312,113 +103,38 @@ function composeArtifactPaths(
 /**
  * Factory that returns a composed graph + temporal {@link OpenStoreResult}.
  *
- *   - `backend: "duck"` → a single `DuckDbStore` instance is returned as
- *     BOTH the `graph` and `temporal` views over the same connection.
- *     No second file. Closing once is sufficient (`close()` is
- *     idempotent on the underlying adapter).
- *   - `backend: "lbug"` → a `GraphDbStore` instance backs the `graph`
- *     view at `<dir>/graph.lbug`; a separate `DuckDbStore` over the
- *     sibling `<dir>/temporal.duckdb` backs the `temporal` view.
- *     `OpenStoreResult.close()` closes both in deterministic order
- *     (graph first, then temporal).
+ * A `GraphDbStore` instance backs the `graph` view at `<dir>/graph.lbug`;
+ * a separate `DuckDbStore` over the sibling `<dir>/temporal.duckdb`
+ * backs the `temporal` view. `OpenStoreResult.close()` closes both in
+ * deterministic order — graph first, temporal second.
  *
  * The factory only constructs — callers still own the `open()` lifecycle
  * call so failures are attributable to the lifecycle boundary rather
- * than the factory. Use {@link OpenStoreResult.close} to release both
- * adapters; closing in deterministic order guarantees parity-test
- * lifecycle cleanup symmetry.
+ * than the factory.
  */
 export async function openStore(opts: OpenStoreOptions): Promise<OpenStoreResult> {
-  // Async resolver — runs the cached `@ladybugdb/core` probe when the
-  // caller asked for `"auto"` and `CODEHUB_STORE` is unset. Explicit
-  // backend / env var paths skip the probe.
-  const initialBackend: ResolvedBackend = await resolveStoreBackendAsync(opts.backend);
-  // Compose the canonical artifact paths for the initial backend, then
-  // run dual-artifact detection. When both `graph.duckdb` and
-  // `graph.lbug` coexist as siblings, the newer-mtime file wins —
-  // this handles the M7 transition where a user re-analyzed under one
-  // backend but the older artifact from the other backend is still on
-  // disk.
-  const initialPaths = composeArtifactPaths(initialBackend, opts.path);
-  const backend = await detectDualArtifacts(
-    initialPaths.graphFile,
-    initialPaths.temporalFile,
-    initialBackend,
-  );
-  let { graphFile, temporalFile } =
-    backend === initialBackend ? initialPaths : composeArtifactPaths(backend, opts.path);
-
-  // Single-artifact fallback: when the probe resolved to a backend whose
-  // file does not exist but the other backend's artifact does, use the
-  // present file. This prevents the lbug binding probe from selecting "lbug"
-  // on a machine where the binding is installed but the existing index is
-  // DuckDB (created before lbug, seeded by tests, or an explicit --store duck
-  // analysis). Only applies when backend was "auto" / unset — explicit
-  // CODEHUB_STORE overrides are always honored.
-  let resolvedBackend = backend;
-  const autoResolved =
-    (opts.backend === "auto" || opts.backend === undefined) &&
-    (process.env[ENV_VAR] === undefined || process.env[ENV_VAR] === "");
-  if (autoResolved && graphFile !== ":memory:") {
-    const graphExists = await stat(graphFile)
-      .then(() => true)
-      .catch(() => false);
-    if (!graphExists) {
-      const altBackend: ResolvedBackend = backend === "lbug" ? "duck" : "lbug";
-      const altPaths = composeArtifactPaths(altBackend, opts.path);
-      const altExists = await stat(altPaths.graphFile)
-        .then(() => true)
-        .catch(() => false);
-      if (altExists) {
-        resolvedBackend = altBackend;
-        ({ graphFile, temporalFile } = altPaths);
-      }
-    }
-  }
+  const { graphFile, temporalFile } = composeArtifactPaths(opts.path);
 
-  const duckOptions: DuckDbStoreOptions = {
-    ...(opts.duckOptions ?? {}),
+  const graphDbOptions: GraphDbStoreOptions = {
+    ...(opts.graphDbOptions ?? {}),
     ...(opts.readOnly !== undefined ? { readOnly: opts.readOnly } : {}),
     ...(opts.embeddingDim !== undefined ? { embeddingDim: opts.embeddingDim } : {}),
     ...(opts.timeoutMs !== undefined ? { timeoutMs: opts.timeoutMs } : {}),
   };
-
-  if (resolvedBackend === "duck") {
-    // Both graph and temporal views resolve to the same instance over a
-    // single DuckDB connection. The class implements both interfaces so
-    // structural typing is satisfied without two wrapper objects.
-    const store = new DuckDbStore(graphFile, duckOptions);
-    return {
-      backend: "duck" satisfies BackendKind,
-      graph: store satisfies IGraphStore,
-      temporal: store satisfies ITemporalStore,
-      graphFile,
-      temporalFile,
-      close: async () => {
-        await store.close();
-      },
-    };
-  }
-
-  // resolvedBackend === "lbug" — graph-db backed graph + DuckDB-backed temporal.
-  const graphDbOptions: GraphDbStoreOptions = {
-    ...(opts.graphDbOptions ?? {}),
+  const duckOptions: DuckDbStoreOptions = {
+    ...(opts.duckOptions ?? {}),
     ...(opts.readOnly !== undefined ? { readOnly: opts.readOnly } : {}),
-    ...(opts.embeddingDim !== undefined ? { embeddingDim: opts.embeddingDim } : {}),
     ...(opts.timeoutMs !== undefined ? { timeoutMs: opts.timeoutMs } : {}),
   };
+
   const graph = new GraphDbStore(graphFile, graphDbOptions);
   const temporal = new DuckDbStore(temporalFile, duckOptions);
   return {
-    backend: resolvedBackend satisfies BackendKind,
-    graph: graph satisfies IGraphStore,
-    temporal: temporal satisfies ITemporalStore,
+    graph,
+    temporal,
     graphFile,
     temporalFile,
     close: async () => {
-      // Close graph first, temporal second — symmetric with open ordering
-      // would be the inverse, but graph adapters tend to hold native
-      // pool handles that benefit from prompt release.
       await graph.close();
       await temporal.close();
     },
diff --git a/packages/storage/src/interface.test.ts b/packages/storage/src/interface.test.ts
index 2ee7db90..0e19b09f 100644
--- a/packages/storage/src/interface.test.ts
+++ b/packages/storage/src/interface.test.ts
@@ -70,7 +70,7 @@ test("IGraphStore-shaped value lacks temporal methods at runtime", () => {
     // intentionally empty
   }
   const graphOnly: IGraphStore = {
-    dialect: "none",
+    dialect: "cypher",
     open: async () => {},
     close: async () => {},
     createSchema: async () => {},
@@ -105,7 +105,7 @@ test("IGraphStore-shaped value lacks temporal methods at runtime", () => {
   assert.equal(typeof bag["lookupCochangesForFile"], "undefined");
   assert.equal(typeof bag["lookupSymbolSummary"], "undefined");
   assert.equal(typeof bag["exec"], "undefined");
-  assert.equal(graphOnly.dialect, "none");
+  assert.equal(graphOnly.dialect, "cypher");
 });
 
 test("ITemporalStore-shaped value lacks graph methods at runtime", () => {
@@ -115,6 +115,7 @@ test("ITemporalStore-shaped value lacks graph methods at runtime", () => {
     createSchema: async () => {},
     healthCheck: async () => ({ ok: true }),
     exec: async () => [],
+    exportEmbeddingsToParquet: async () => ({ rowCount: 0, duckdbVersion: "test" }),
     bulkLoadCochanges: async () => {},
     lookupCochangesForFile: async (): Promise<readonly CochangeRow[]> => [],
     lookupCochangesBetween: async () => undefined,
@@ -136,15 +137,13 @@ test("Store alias matches OpenStoreResult composition", () => {
   // type level. The runtime side of this test asserts that a properly-
   // typed Store value carries the four required keys.
   const dummy: Store = {
-    backend: "duck",
     graph: undefined as unknown as IGraphStore,
     temporal: undefined as unknown as ITemporalStore,
-    graphFile: "/tmp/graph.duckdb",
-    temporalFile: "/tmp/graph.duckdb",
+    graphFile: "/tmp/.codehub/graph.lbug",
+    temporalFile: "/tmp/.codehub/temporal.duckdb",
     close: async () => {},
   };
-  assert.equal(dummy.backend, "duck");
-  assert.equal(dummy.graphFile, "/tmp/graph.duckdb");
-  assert.equal(dummy.temporalFile, dummy.graphFile);
+  assert.equal(dummy.graphFile, "/tmp/.codehub/graph.lbug");
+  assert.equal(dummy.temporalFile, "/tmp/.codehub/temporal.duckdb");
   assert.equal(typeof dummy.close, "function");
 });
diff --git a/packages/storage/src/interface.ts b/packages/storage/src/interface.ts
index 960517bc..b1371d07 100644
--- a/packages/storage/src/interface.ts
+++ b/packages/storage/src/interface.ts
@@ -5,7 +5,7 @@
  *
  *   1. {@link IGraphStore} — graph-tier, pure graph operations only:
  *      nodes, edges, traversals, BM25 search, vector search, embeddings.
- *      NO SQL, NO cochanges, NO symbol summaries. Cypher dialect or none.
+ *      NO SQL, NO cochanges, NO symbol summaries. Cypher dialect.
  *      The portable interface community AGE / Memgraph / Neo4j / Neptune
  *      adapters target.
  *   2. {@link ITemporalStore} — tabular-tier, SQL-only operations:
@@ -17,9 +17,9 @@
  * Callers that need both surfaces use {@link openStore} and consume the
  * resulting {@link OpenStoreResult} `{graph, temporal, close, ...}`.
  *
- * The DuckDB adapter exposes BOTH views over one connection (no second
- * file when DuckDB is the only backend). The graph-db adapter (via
- * `@ladybugdb/core`) is graph-only and pairs with a DuckDB temporal store.
+ * The graph-db adapter (via `@ladybugdb/core`) is graph-only and pairs
+ * with a DuckDB temporal store. The DuckDB adapter is temporal-only —
+ * cochanges, symbol summaries, and the `--sql` escape hatch.
  *
  * ## Sentinel rules
  *
@@ -75,23 +75,14 @@ import type {
   RouteNode,
 } from "@opencodehub/core-types";
 
-/**
- * Concrete backend identifiers recognized by {@link openStore}. `"duck"`
- * (DuckDB) and `"lbug"` (graph-db backend via `@ladybugdb/core`) are the
- * in-tree implementations. `"age"`, `"memgraph"`, `"neo4j"`, and
- * `"neptune"` are reserved for plausible community-fork adapters; they
- * are not implemented here.
- */
-export type BackendKind = "duck" | "lbug" | "age" | "memgraph" | "neo4j" | "neptune";
-
 /**
  * Graph dialect a given {@link IGraphStore} adapter speaks. The optional
  * {@link IGraphStore.execCypher} escape hatch only makes sense when the
- * dialect is `"cypher"`. The DuckDB adapter sets `"none"` because its
- * `nodes`/`relations` tables expose no public Cypher entry point — the
- * typed finders cover every internal need.
+ * dialect is `"cypher"`. Reserved as a type rather than a literal so a
+ * future community adapter (e.g. AGE, Neo4j) can keep the surface stable
+ * while still carrying its own dialect tag.
  */
-export type GraphDialect = "cypher" | "none";
+export type GraphDialect = "cypher";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // IGraphStore — graph-tier only
@@ -143,9 +134,9 @@ export type GraphDialect = "cypher" | "none";
  */
 export interface IGraphStore {
   /**
-   * Cypher dialect spoken by this adapter, or `"none"` if no public
-   * Cypher entry point is exposed. OCH core never branches on this — it
-   * is published for community adapters and documentation tooling.
+   * Cypher dialect spoken by this adapter. OCH core never branches on
+   * this — it is published for community adapters and documentation
+   * tooling.
    */
   readonly dialect: GraphDialect;
 
@@ -424,6 +415,21 @@ export interface ITemporalStore {
     opts?: { readonly timeoutMs?: number },
   ): Promise<readonly Record<string, unknown>[]>;
 
+  /**
+   * Stage an `EmbeddingRow` stream through a per-call DuckDB temp table and
+   * COPY it to a Parquet file. Used by `pack/embeddings-sidecar.ts` to
+   * produce the deterministic Parquet sidecar from rows that originate in
+   * `graph.lbug`. The temp table is dropped before the call returns.
+   *
+   * Returns `{rowCount: 0}` when the stream is empty (no file written).
+   * `duckdbVersion` is the runtime `SELECT version()` result — pinned by
+   * the pack manifest so the writer version stays bound to the artifact.
+   */
+  exportEmbeddingsToParquet(
+    rows: AsyncIterable<EmbeddingRow>,
+    absOutPath: string,
+  ): Promise<{ readonly rowCount: number; readonly duckdbVersion: string }>;
+
   // ── Cochange surface (was on IGraphStore via CochangeStore) ───────────────
   /** Replace the cochanges table contents with the supplied rows. */
   bulkLoadCochanges(rows: readonly CochangeRow[]): Promise<void>;
@@ -469,20 +475,18 @@ export interface ITemporalStore {
 
 /**
  * Composed result of {@link openStore}. The caller closes both views via
- * the deterministic {@link OpenStoreResult.close} method (which closes
- * temporal first when the two views share a backing connection, and
- * closes graph first otherwise — adapters guarantee idempotence).
+ * the deterministic {@link OpenStoreResult.close} method (graph closes
+ * first, then temporal — graph adapters tend to hold native pool
+ * handles that benefit from prompt release).
  */
 export interface OpenStoreResult {
-  /** Concrete backend selected after env + binding resolution. */
-  readonly backend: BackendKind;
-  /** Graph-tier view. */
+  /** Graph-tier view (always lbug). */
   readonly graph: IGraphStore;
-  /** Tabular-tier view. */
+  /** Tabular-tier view (always DuckDB). */
   readonly temporal: ITemporalStore;
-  /** Absolute path to the on-disk graph artifact. */
+  /** Absolute path to the on-disk graph artifact (`graph.lbug`). */
   readonly graphFile: string;
-  /** Absolute path to the on-disk temporal artifact. May equal `graphFile` (DuckDB-only deployments). */
+  /** Absolute path to the on-disk temporal artifact (`temporal.duckdb`). */
   readonly temporalFile: string;
   /** Closes both views in deterministic order. Idempotent. */
   close(): Promise<void>;
@@ -490,18 +494,8 @@ export interface OpenStoreResult {
 
 /** Inputs to {@link openStore}. */
 export interface OpenStoreOptions {
-  /** Filesystem path to the database file (or directory housing both files). */
+  /** Filesystem path to the `<repo>/.codehub/` graph artifact file. */
   readonly path: string;
-  /**
-   * Backend selector:
-   *   - `"duck"` — single DuckDB file backs BOTH graph and temporal views.
-   *   - `"lbug"` — graph-db backend (`@ladybugdb/core`) for graph; a paired
-   *     DuckDB file at `<path>.temporal.duckdb` for temporal.
-   *   - `"auto"` — read the `CODEHUB_STORE` env var; when unset, probe
-   *     `@ladybugdb/core` and prefer the graph backend on success, else
-   *     fall back to DuckDB.
-   */
-  readonly backend?: BackendKind | "auto";
   readonly readOnly?: boolean;
   readonly embeddingDim?: number;
   readonly timeoutMs?: number;
@@ -551,21 +545,6 @@ export interface CochangeLookupOptions {
   readonly minLift?: number;
 }
 
-/**
- * @deprecated The cochange surface is folded into {@link ITemporalStore}.
- * The named alias is retained transiently so test fakes that satisfy
- * the older shape keep compiling. New code consumes `ITemporalStore`
- * directly via {@link OpenStoreResult.temporal}.
- */
-export interface CochangeStore {
-  bulkLoadCochanges(rows: readonly CochangeRow[]): Promise<void>;
-  lookupCochangesForFile(
-    file: string,
-    opts?: CochangeLookupOptions,
-  ): Promise<readonly CochangeRow[]>;
-  lookupCochangesBetween(fileA: string, fileB: string): Promise<CochangeRow | undefined>;
-}
-
 // ─────────────────────────────────────────────────────────────────────────────
 // Symbol-summary row (used by ITemporalStore)
 // ─────────────────────────────────────────────────────────────────────────────
@@ -604,22 +583,6 @@ export interface SymbolSummaryRow {
   readonly createdAt: string;
 }
 
-/**
- * @deprecated The symbol-summary surface is folded into {@link ITemporalStore}.
- * The named alias is retained transiently so test fakes that satisfy
- * the older shape keep compiling. New code consumes `ITemporalStore`
- * directly via {@link OpenStoreResult.temporal}.
- */
-export interface SymbolSummaryStore {
-  bulkLoadSymbolSummaries(rows: readonly SymbolSummaryRow[]): Promise<void>;
-  lookupSymbolSummary(
-    nodeId: string,
-    contentHash: string,
-    promptVersion: string,
-  ): Promise<SymbolSummaryRow | undefined>;
-  lookupSymbolSummariesByNode(nodeIds: readonly string[]): Promise<readonly SymbolSummaryRow[]>;
-}
-
 // ─────────────────────────────────────────────────────────────────────────────
 // Shared options + result types
 // ─────────────────────────────────────────────────────────────────────────────
@@ -808,6 +771,47 @@ export interface BulkLoadOptions {
    * unrelated rows.
    */
   readonly mode?: "replace" | "upsert";
+  /**
+   * Optional progress sink the writer calls during long-running bulk
+   * operations (truncate, node batches, edge-kind batches). Lets the CLI
+   * surface "85% of nodes inserted" lines so an operator can tell the
+   * difference between "still working" and "hung" — `codehub analyze`
+   * spends most of its wall-clock time inside `bulkLoad` on a graph-db
+   * backend (UNWIND-batched per-batch + per-rel-kind cost), and a silent
+   * 30+ second pause is the dominant operator-feedback complaint.
+   *
+   * Errors thrown from the callback are swallowed so a buggy reporter
+   * cannot mask a real bulk-load failure.
+   */
+  readonly onProgress?: (ev: BulkLoadProgressEvent) => void;
+}
+
+/**
+ * Progress event emitted by {@link IGraphStore.bulkLoad}. The shape is
+ * intentionally narrow — `kind` identifies the stage, `done`/`total` carry
+ * the work-units, and `elapsedMs` lets the CLI spot stalls. Adapters that
+ * cannot produce meaningful counts may omit the numeric fields.
+ */
+export interface BulkLoadProgressEvent {
+  readonly kind:
+    | "truncate-start"
+    | "truncate-end"
+    | "nodes-start"
+    | "nodes-batch"
+    | "nodes-end"
+    | "edges-start"
+    | "edges-batch"
+    | "edges-end";
+  /** Edge relation type the event refers to (only set for edge events). */
+  readonly relType?: string;
+  /** Items completed so far at this stage. Cumulative within the stage. */
+  readonly done?: number;
+  /** Total items expected at this stage. */
+  readonly total?: number;
+  /** Milliseconds since the bulk-load started. */
+  readonly elapsedMs?: number;
+  /** Free-form note (e.g. "skipping empty rel-kind") for `*-end` events. */
+  readonly message?: string;
 }
 
 /**
diff --git a/packages/storage/src/paths.test.ts b/packages/storage/src/paths.test.ts
index 662ca968..7afd5c5c 100644
--- a/packages/storage/src/paths.test.ts
+++ b/packages/storage/src/paths.test.ts
@@ -7,7 +7,7 @@ import {
   META_DIR_NAME,
   META_FILE_NAME,
   REGISTRY_FILE_NAME,
-  resolveDbPath,
+  resolveGraphPath,
   resolveMetaFilePath,
   resolveRegistryPath,
   resolveRepoMetaDir,
@@ -18,12 +18,9 @@ test("resolveRepoMetaDir: joins repo path with .codehub", () => {
   assert.equal(actual, resolve("/tmp/demo-repo", META_DIR_NAME));
 });
 
-test("resolveDbPath: drops the DuckDB file inside the meta dir", () => {
-  const actual = resolveDbPath("/tmp/demo-repo");
-  assert.equal(
-    actual,
-    resolve("/tmp/demo-repo", META_DIR_NAME, describeArtifacts("duck").graphFile),
-  );
+test("resolveGraphPath: drops the lbug graph file inside the meta dir", () => {
+  const actual = resolveGraphPath("/tmp/demo-repo");
+  assert.equal(actual, resolve("/tmp/demo-repo", META_DIR_NAME, describeArtifacts().graphFile));
 });
 
 test("resolveMetaFilePath: drops meta.json inside the meta dir", () => {
@@ -47,23 +44,9 @@ test("resolveRepoMetaDir: resolves relative paths", () => {
   assert.equal(actual, resolve(process.cwd(), "demo-repo", META_DIR_NAME));
 });
 
-test("describeArtifacts: duck collapses graph + temporal to a single file", () => {
-  const actual = describeArtifacts("duck");
-  assert.equal(actual.graphFile, "graph.duckdb");
-  assert.equal(actual.temporalFile, "graph.duckdb");
-  assert.equal(actual.schemaName, "main");
-});
-
-test("describeArtifacts: lbug splits graph + temporal across two files", () => {
-  const actual = describeArtifacts("lbug");
+test("describeArtifacts: returns lbug + duckdb temporal pair", () => {
+  const actual = describeArtifacts();
   assert.equal(actual.graphFile, "graph.lbug");
   assert.equal(actual.temporalFile, "temporal.duckdb");
   assert.equal(actual.schemaName, "main");
 });
-
-test("describeArtifacts: community backends fall back to graph.<backend> + temporal.duckdb", () => {
-  const actual = describeArtifacts("neo4j");
-  assert.equal(actual.graphFile, "graph.neo4j");
-  assert.equal(actual.temporalFile, "temporal.duckdb");
-  assert.equal(actual.schemaName, "main");
-});
diff --git a/packages/storage/src/paths.ts b/packages/storage/src/paths.ts
index b3597cba..ee15b076 100644
--- a/packages/storage/src/paths.ts
+++ b/packages/storage/src/paths.ts
@@ -3,58 +3,38 @@
  *
  * These helpers are pure — they never touch the filesystem — so they are
  * trivially testable. Resolution rules:
- *   - Per-repo: `<repo>/.codehub/` holds the graph + temporal artifacts
- *     plus the meta sidecar. The exact filenames depend on the backend
- *     (see {@link describeArtifacts}).
+ *   - Per-repo: `<repo>/.codehub/` holds `graph.lbug` (graph artifact)
+ *     and `temporal.duckdb` (cochange + symbol-summary sidecar) plus the
+ *     meta sidecar `meta.json`.
  *   - Global : `~/.codehub/registry.json` holds the cross-repo registry.
  */
 
 import { homedir } from "node:os";
 import { resolve } from "node:path";
-import type { BackendKind } from "./interface.js";
 
 export const META_DIR_NAME = ".codehub";
 export const META_FILE_NAME = "meta.json";
 export const REGISTRY_FILE_NAME = "registry.json";
 
 /**
- * Canonical artifact filenames per backend. Used by:
+ * Canonical artifact filenames. Used by:
  *
  *   - The `openStore` factory to construct the graph + temporal file
  *     paths from a single `<dir>/.codehub/` parent.
  *   - The `codehub list` indexed-status probe to decide whether a repo
- *     has any backend's artifact on disk.
- *   - The MCP error envelope to enumerate all candidate paths in the
+ *     has any artifact on disk.
+ *   - The MCP error envelope to enumerate candidate paths in the
  *     "store unreadable" message.
  *
- * Two-store backends (e.g. `lbug`) split the graph and temporal views
- * into siblings:
- *   - `graphFile`    → `graph.lbug` (graph-db engine owns this file)
- *   - `temporalFile` → `temporal.duckdb` (DuckDB sibling for time series)
- *
- * Single-store backends (`duck`) collapse to one file used as both the
- * graph and temporal view (one connection serves both).
- *
  * `schemaName` is the namespace used inside the graph artifact when the
- * backend supports schemas; for both `duck` and `lbug` we emit into the
- * default `main` schema.
+ * backend supports schemas; lbug emits into the default `main` schema.
  */
-export function describeArtifacts(backend: BackendKind): {
+export function describeArtifacts(): {
   readonly graphFile: string;
   readonly temporalFile: string;
   readonly schemaName: string;
 } {
-  if (backend === "duck") {
-    return { graphFile: "graph.duckdb", temporalFile: "graph.duckdb", schemaName: "main" };
-  }
-  if (backend === "lbug") {
-    return { graphFile: "graph.lbug", temporalFile: "temporal.duckdb", schemaName: "main" };
-  }
-  // Community-adapter backends (`age`, `memgraph`, `neo4j`, `neptune`)
-  // declare their on-disk layout via separate path resolution; the
-  // generic fallback derives the graph filename from the backend id and
-  // pairs it with a sibling DuckDB temporal file.
-  return { graphFile: `graph.${backend}`, temporalFile: "temporal.duckdb", schemaName: "main" };
+  return { graphFile: "graph.lbug", temporalFile: "temporal.duckdb", schemaName: "main" };
 }
 
 /** Resolve the `<repo>/.codehub` directory (repo path may be relative). */
@@ -63,16 +43,12 @@ export function resolveRepoMetaDir(repoPath: string): string {
 }
 
 /**
- * Resolve the legacy DuckDB graph artifact path
- * (`<repo>/.codehub/graph.duckdb`). Retained as the canonical entry
- * point for callers that pass a single path into the `openStore`
- * factory; the factory rewrites the filename when the resolved backend
- * is not `duck`. New callers should prefer {@link describeArtifacts}
- * combined with {@link resolveRepoMetaDir} when they need a specific
- * backend's artifact path.
+ * Resolve the canonical graph artifact path
+ * (`<repo>/.codehub/graph.lbug`). The {@link openStore} factory derives
+ * the sibling temporal artifact path automatically.
  */
-export function resolveDbPath(repoPath: string): string {
-  return resolve(repoPath, META_DIR_NAME, describeArtifacts("duck").graphFile);
+export function resolveGraphPath(repoPath: string): string {
+  return resolve(repoPath, META_DIR_NAME, describeArtifacts().graphFile);
 }
 
 /** Resolve the `<repo>/.codehub/meta.json` sidecar path. */
diff --git a/packages/storage/src/resolver.test.ts b/packages/storage/src/resolver.test.ts
deleted file mode 100644
index 464e400c..00000000
--- a/packages/storage/src/resolver.test.ts
+++ /dev/null
@@ -1,169 +0,0 @@
-/**
-/**
- * Tests for the async backend resolver + dual-artifact detection.
- *
- * The sync `resolveStoreBackend` env-var resolution lives next door in
- * `graphdb-adapter.test.ts:141-161`. This file covers:
- *
- *   - `resolveStoreBackendAsync` — graph-default async resolver.
- *   - `detectDualArtifacts` — the newer-mtime-wins helper.
- */
-
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, utimesSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, test } from "node:test";
-import {
-  _resetStoreResolverCache,
-  detectDualArtifacts,
-  resolveStoreBackendAsync,
-} from "./index.js";
-
-beforeEach(() => {
-  _resetStoreResolverCache();
-});
-
-afterEach(() => {
-  _resetStoreResolverCache();
-});
-
-// ---------------------------------------------------------------------------
-// resolveStoreBackendAsync
-// ---------------------------------------------------------------------------
-
-test("resolveStoreBackendAsync: explicit backend bypasses the probe", async () => {
-  let probeCalls = 0;
-  const probe = async () => {
-    probeCalls++;
-    return true;
-  };
-  assert.equal(await resolveStoreBackendAsync("duck", {}, probe), "duck");
-  assert.equal(await resolveStoreBackendAsync("lbug", {}, probe), "lbug");
-  assert.equal(probeCalls, 0);
-});
-
-test("resolveStoreBackendAsync: env CODEHUB_STORE wins over probe", async () => {
-  let probeCalls = 0;
-  const probe = async () => {
-    probeCalls++;
-    return true;
-  };
-  assert.equal(await resolveStoreBackendAsync("auto", { CODEHUB_STORE: "duck" }, probe), "duck");
-  assert.equal(await resolveStoreBackendAsync("auto", { CODEHUB_STORE: "lbug" }, probe), "lbug");
-  assert.equal(probeCalls, 0);
-});
-
-test("resolveStoreBackendAsync: auto + unset + probe success → lbug", async () => {
-  const probe = async () => true;
-  assert.equal(await resolveStoreBackendAsync("auto", {}, probe), "lbug");
-  // undefined backend is treated as auto.
-  assert.equal(await resolveStoreBackendAsync(undefined, {}, probe), "lbug");
-});
-
-test("resolveStoreBackendAsync: auto + unset + probe failure → duck (silent in non-TTY)", async () => {
-  const probe = async () => false;
-  // No TTY, no OCH_VERBOSE → no stderr emitted, just falls back.
-  assert.equal(await resolveStoreBackendAsync("auto", {}, probe), "duck");
-});
-
-test("resolveStoreBackendAsync: invalid CODEHUB_STORE rejects", async () => {
-  const probe = async () => true;
-  await assert.rejects(
-    () => resolveStoreBackendAsync("auto", { CODEHUB_STORE: "sqlite" }, probe),
-    /Invalid CODEHUB_STORE/,
-  );
-});
-
-test("resolveStoreBackendAsync: rejects in-tree-unsupported community backends", async () => {
-  const probe = async () => true;
-  await assert.rejects(
-    () => resolveStoreBackendAsync("age" as never, {}, probe),
-    /reserved for community adapters/,
-  );
-});
-
-// ---------------------------------------------------------------------------
-// detectDualArtifacts
-// ---------------------------------------------------------------------------
-
-let tmpDir: string;
-
-beforeEach(() => {
-  tmpDir = mkdtempSync(join(tmpdir(), "och-dual-artifact-"));
-});
-
-afterEach(() => {
-  rmSync(tmpDir, { recursive: true, force: true });
-});
-
-function touch(file: string, mtime: Date): void {
-  writeFileSync(file, "");
-  utimesSync(file, mtime, mtime);
-}
-
-test("detectDualArtifacts: in-memory paths short-circuit", async () => {
-  assert.equal(await detectDualArtifacts(":memory:", ":memory:", "duck", {}), "duck");
-  assert.equal(await detectDualArtifacts(":memory:", ":memory:", "lbug", {}), "lbug");
-});
-
-test("detectDualArtifacts: only one file present → backend unchanged", async () => {
-  const duckPath = join(tmpDir, "graph.duckdb");
-  touch(duckPath, new Date(2026, 0, 1));
-  // Backend resolved to lbug; lbug file does not exist; respect the
-  // resolution. The factory will create the lbug file later.
-  assert.equal(await detectDualArtifacts(duckPath, duckPath, "lbug", {}), "lbug");
-});
-
-test("detectDualArtifacts: both present, duckdb newer → wins", async () => {
-  const duckPath = join(tmpDir, "graph.duckdb");
-  const lbugPath = join(tmpDir, "graph.lbug");
-  // duck mtime newer than lbug.
-  touch(lbugPath, new Date(2026, 0, 1));
-  touch(duckPath, new Date(2026, 0, 5));
-  assert.equal(
-    await detectDualArtifacts(lbugPath, join(tmpDir, "temporal.duckdb"), "lbug", {}),
-    "duck",
-  );
-});
-
-test("detectDualArtifacts: both present, lbug newer → wins", async () => {
-  const duckPath = join(tmpDir, "graph.duckdb");
-  const lbugPath = join(tmpDir, "graph.lbug");
-  // lbug mtime newer than duck.
-  touch(duckPath, new Date(2026, 0, 1));
-  touch(lbugPath, new Date(2026, 0, 5));
-  assert.equal(await detectDualArtifacts(duckPath, duckPath, "duck", {}), "lbug");
-});
-
-test("detectDualArtifacts: both present, override emits one-shot advisory under OCH_VERBOSE=1", async () => {
-  const duckPath = join(tmpDir, "graph.duckdb");
-  const lbugPath = join(tmpDir, "graph.lbug");
-  touch(lbugPath, new Date(2026, 0, 1));
-  touch(duckPath, new Date(2026, 0, 5));
-
-  let captured = "";
-  const original = process.stderr.write.bind(process.stderr);
-  // biome-ignore lint/suspicious/noExplicitAny: stderr.write monkey-patch needs a cast
-  (process.stderr as any).write = (chunk: string | Uint8Array): boolean => {
-    captured += chunk.toString();
-    return true;
-  };
-  try {
-    assert.equal(
-      await detectDualArtifacts(lbugPath, lbugPath, "lbug", { OCH_VERBOSE: "1" }),
-      "duck",
-    );
-    // Second call must not double-emit (one-shot guard).
-    assert.equal(
-      await detectDualArtifacts(lbugPath, lbugPath, "lbug", { OCH_VERBOSE: "1" }),
-      "duck",
-    );
-  } finally {
-    // biome-ignore lint/suspicious/noExplicitAny: restore monkey-patch
-    (process.stderr as any).write = original;
-  }
-  assert.match(captured, /both graph\.duckdb and graph\.lbug found/);
-  // Single occurrence.
-  assert.equal(captured.match(/found in/g)?.length, 1);
-});
diff --git a/packages/storage/src/schema-ddl.ts b/packages/storage/src/schema-ddl.ts
index 32869ddd..5bbad72c 100644
--- a/packages/storage/src/schema-ddl.ts
+++ b/packages/storage/src/schema-ddl.ts
@@ -1,196 +1,32 @@
 /**
- * DDL emitter for the DuckDB-backed graph store.
+ * DDL emitter for the DuckDB-backed temporal store.
  *
- * Every node kind collapses into a single polymorphic `nodes` table. Kinds
- * that don't populate a column leave it NULL — the cost is a few NULL slots
- * per row in exchange for avoiding 31 near-identical CREATE TABLE statements
- * and 31 different SELECT paths in the reader. Relations live in `relations`
- * with a `type` discriminator. Embeddings live in a separate `embeddings`
- * table whose vector column is a FIXED-SIZE FLOAT array of the dimension
- * configured at construction time.
+ * Two tables only:
+ *   - `cochanges` — file-level association statistics from git history.
+ *   - `symbol_summaries` — structured per-symbol summaries from the
+ *     ingestion summarize phase, keyed by
+ *     `(node_id, content_hash, prompt_version)`.
+ *
+ * The graph tier (nodes/edges/embeddings/store_meta) lives in the lbug
+ * graph artifact; this DDL is intentionally narrow.
  */
 
 export interface SchemaOptions {
-  /** Dimension for the fixed-size FLOAT array used by the embeddings column. */
-  readonly embeddingDim: number;
+  /**
+   * Retained for API symmetry with the prior multi-tier schema; the
+   * temporal-only DDL never references it. Callers that supply it pay
+   * one validation check; omitting it is also accepted.
+   */
+  readonly embeddingDim?: number;
 }
 
 /**
- * Returns a sequence of DDL statements that must be executed in order. The
- * adapter runs them one-at-a-time so it can also run `INSTALL`/`LOAD` calls
- * interleaved at the right moments.
+ * Returns a sequence of DDL statements that must be executed in order.
  */
-export function generateSchemaDDL(opts: SchemaOptions): readonly string[] {
-  if (!Number.isInteger(opts.embeddingDim) || opts.embeddingDim <= 0) {
-    throw new Error(`Invalid embeddingDim: ${opts.embeddingDim}`);
-  }
-  const dim = opts.embeddingDim;
-
+export function generateSchemaDDL(_opts: SchemaOptions = {}): readonly string[] {
   return [
-    `CREATE TABLE IF NOT EXISTS nodes (
-      id                   TEXT PRIMARY KEY,
-      kind                 TEXT NOT NULL,
-      name                 TEXT NOT NULL,
-      file_path            TEXT NOT NULL,
-      start_line           INTEGER,
-      end_line             INTEGER,
-      is_exported          BOOLEAN,
-      signature            TEXT,
-      parameter_count      INTEGER,
-      return_type          TEXT,
-      declared_type        TEXT,
-      owner                TEXT,
-      url                  TEXT,
-      method               TEXT,
-      tool_name            TEXT,
-      content              TEXT,
-      content_hash         TEXT,
-      inferred_label       TEXT,
-      symbol_count         INTEGER,
-      cohesion             DOUBLE,
-      keywords             TEXT[],
-      entry_point_id       TEXT,
-      step_count           INTEGER,
-      level                INTEGER,
-      response_keys        TEXT[],
-      description          TEXT,
-      -- Finding (SARIF)
-      severity             TEXT,
-      rule_id              TEXT,
-      scanner_id           TEXT,
-      message              TEXT,
-      properties_bag       TEXT,
-      -- Dependency (SBOM / manifest)
-      version              TEXT,
-      license              TEXT,
-      lockfile_source      TEXT,
-      ecosystem            TEXT,
-      -- Operation (OpenAPI)
-      http_method          TEXT,
-      http_path            TEXT,
-      summary              TEXT,
-      operation_id         TEXT,
-      -- Contributor (git blame)
-      email_hash           TEXT,
-      email_plain          TEXT,
-      -- ProjectProfile
-      languages_json       TEXT,
-      frameworks_json      TEXT,
-      iac_types_json       TEXT,
-      api_contracts_json   TEXT,
-      manifests_json       TEXT,
-      src_dirs_json        TEXT,
-      -- File ownership (H.5) and Community ownership (H.4)
-      orphan_grade         TEXT,
-      is_orphan            BOOLEAN,
-      truck_factor         INTEGER,
-      ownership_drift_30d  DOUBLE,
-      ownership_drift_90d  DOUBLE,
-      ownership_drift_365d DOUBLE,
-      -- v1.2 extensions (append-only: preserves load-bearing column order).
-      -- dead-code phase: deadness. coverage phase: coverage_percent and
-      -- covered_lines_json. complexity phase: cyclomatic_complexity,
-      -- nesting_depth, nloc, halstead_volume. tools phase:
-      -- input_schema_json. SARIF ingest: partial_fingerprint,
-      -- baseline_state, suppressed_json.
-      deadness             TEXT,
-      coverage_percent     DOUBLE,
-      covered_lines_json   TEXT,
-      cyclomatic_complexity INTEGER,
-      nesting_depth        INTEGER,
-      nloc                 INTEGER,
-      halstead_volume      DOUBLE,
-      input_schema_json    TEXT,
-      partial_fingerprint  TEXT,
-      baseline_state       TEXT,
-      suppressed_json      TEXT,
-      -- Repo. One row per indexed repository. The "group" field is a
-      -- reserved SQL keyword, so the column is named repo_group. The
-      -- index_time field is node-level metadata that is deliberately
-      -- excluded from graphHash determinism inputs.
-      origin_url           TEXT,
-      repo_uri             TEXT,
-      default_branch       TEXT,
-      commit_sha           TEXT,
-      index_time           TEXT,
-      repo_group           TEXT,
-      visibility           TEXT,
-      indexer              TEXT,
-      language_stats_json  TEXT
-    )`,
-
-    `CREATE INDEX IF NOT EXISTS idx_nodes_kind ON nodes (kind)`,
-    `CREATE INDEX IF NOT EXISTS idx_nodes_file_path ON nodes (file_path)`,
-    `CREATE INDEX IF NOT EXISTS idx_nodes_name ON nodes (name)`,
-
-    `CREATE TABLE IF NOT EXISTS relations (
-      id          TEXT PRIMARY KEY,
-      from_id     TEXT NOT NULL,
-      to_id       TEXT NOT NULL,
-      type        TEXT NOT NULL,
-      confidence  DOUBLE NOT NULL,
-      reason      TEXT,
-      step        INTEGER NOT NULL DEFAULT 0
-    )`,
-
-    `CREATE INDEX IF NOT EXISTS idx_relations_from ON relations (from_id)`,
-    `CREATE INDEX IF NOT EXISTS idx_relations_to ON relations (to_id)`,
-    `CREATE INDEX IF NOT EXISTS idx_relations_type ON relations (type)`,
-    `CREATE INDEX IF NOT EXISTS idx_relations_confidence ON relations (confidence)`,
-
-    // `granularity` discriminates hierarchical embedding tiers (P03): rows at
-    // 'symbol' granularity mirror the v1.0 behaviour; 'file' and 'community'
-    // tiers are additive. The DEFAULT clause backfills legacy v1.0 rows to
-    // 'symbol' when a v1.2 reader opens an older file — no re-index required.
-    // A single HNSW index covers the column; filter-aware traversal via
-    // `hnsw_acorn` push-down keeps one index serving all three tiers.
-    `CREATE TABLE IF NOT EXISTS embeddings (
-      id            TEXT PRIMARY KEY,
-      node_id       TEXT NOT NULL,
-      granularity   TEXT NOT NULL DEFAULT 'symbol',
-      chunk_index   INTEGER NOT NULL,
-      start_line    INTEGER,
-      end_line      INTEGER,
-      vector        FLOAT[${dim}] NOT NULL,
-      content_hash  TEXT NOT NULL
-    )`,
-
-    // In-place migration: older DuckDB files that were created against the
-    // v1.0 schema lack the `granularity` column entirely. DuckDB rejects
-    // ADD COLUMN … NOT NULL (see DuckDB "Parser Error: Adding columns with
-    // constraints not yet supported"), so we add it nullable with a
-    // DEFAULT, then fill rows where the column is NULL. On a fresh index
-    // the CREATE TABLE above already shipped the column — this pair of
-    // statements is a cheap no-op in that case.
-    `ALTER TABLE embeddings ADD COLUMN IF NOT EXISTS granularity TEXT DEFAULT 'symbol'`,
-    `UPDATE embeddings SET granularity = 'symbol' WHERE granularity IS NULL`,
-
-    `CREATE INDEX IF NOT EXISTS idx_embeddings_node ON embeddings (node_id)`,
-    `CREATE INDEX IF NOT EXISTS idx_embeddings_hash ON embeddings (content_hash)`,
-    `CREATE INDEX IF NOT EXISTS idx_embeddings_granularity ON embeddings (granularity)`,
-
-    `CREATE TABLE IF NOT EXISTS store_meta (
-      id                  INTEGER PRIMARY KEY,
-      schema_version      TEXT NOT NULL,
-      last_commit         TEXT,
-      indexed_at          TEXT NOT NULL,
-      node_count          INTEGER NOT NULL,
-      edge_count          INTEGER NOT NULL,
-      stats_json          TEXT,
-      cache_hit_ratio     DOUBLE,
-      cache_size_bytes    BIGINT,
-      last_compaction     TEXT,
-      embedder_model_id   TEXT
-    )`,
-    // Older stores without the embedder fingerprint column get it
-    // here; pre-existing rows stay NULL so the open-time backfill can
-    // attribute them to the currently-active embedder with a one-shot warning.
-    `ALTER TABLE store_meta ADD COLUMN IF NOT EXISTS embedder_model_id TEXT`,
-
-    // File-level co-change table. Separate from `relations` because the signal
-    // is statistical (not deterministic), file-granular, and rewrites on every
-    // commit; stretching it across the symbol-level graph inflated edge counts
-    // by ~5x on real repos and swamped impact traversals with noise.
+    // File-level co-change table. The signal is statistical (not deterministic),
+    // file-granular, and rewrites on every commit.
     `CREATE TABLE IF NOT EXISTS cochanges (
       source_file            TEXT NOT NULL,
       target_file            TEXT NOT NULL,
@@ -208,8 +44,7 @@ export function generateSchemaDDL(opts: SchemaOptions): readonly string[] {
     // Symbol-level structured summaries. Keyed by (node_id, content_hash,
     // prompt_version) so prompt iteration and source-text drift don't
     // collide. Summaries are side-channel content — they do NOT participate
-    // in the graph edge set. Separate from `embeddings` because summaries
-    // and their embeddings are fused at query time, not at write time.
+    // in the graph edge set.
     `CREATE TABLE IF NOT EXISTS symbol_summaries (
       node_id              TEXT NOT NULL,
       content_hash         TEXT NOT NULL,
diff --git a/packages/storage/src/temporal-parity.test.ts b/packages/storage/src/temporal-parity.test.ts
deleted file mode 100644
index 6d608c95..00000000
--- a/packages/storage/src/temporal-parity.test.ts
+++ /dev/null
@@ -1,266 +0,0 @@
-/**
- * ITemporalStore parity gate.
- *
- * The storage interface is split into {@link IGraphStore} (graph-only)
- * and {@link ITemporalStore} (tabular-only). Cochange + symbol-summary
- * rows live exclusively on the DuckDB-backed temporal view regardless
- * of which graph backend the caller picked.
- *
- * This file is the parity tripwire for that contract:
- *
- *   1. The ITemporalStore methods exposed by `openStore({backend:"duck"})`
- *      and `openStore({backend:"lbug"})` round-trip cochange + symbol
- *      summary rows identically (byte-equivalent JS values).
- *   2. The `OpenStoreResult.temporalFile` path is `<dir>/temporal.duckdb`
- *      under the `lbug` backend (sibling to `graph.lbug`) and equal to
- *      `OpenStoreResult.graphFile` under the `duck` backend (single
- *      shared connection).
- *
- * Because both backends route ITemporalStore through DuckDbStore, the
- * native graph-db binding is NOT required for these tests — we only ever
- * open the `temporal` view, never the `graph` view. The graph-tier
- * round-trip is covered by `graph-hash-parity.test.ts`.
- */
-
-import assert from "node:assert/strict";
-import { mkdtemp } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { test } from "node:test";
-import { openStore } from "./index.js";
-import type {
-  CochangeRow,
-  ITemporalStore,
-  OpenStoreResult,
-  SymbolSummaryRow,
-} from "./interface.js";
-
-async function scratchDir(prefix: string): Promise<string> {
-  return mkdtemp(join(tmpdir(), prefix));
-}
-
-/** Path to the legacy graph.duckdb filename inside a fresh scratch dir. */
-async function scratchDbPath(prefix: string): Promise<string> {
-  const dir = await scratchDir(prefix);
-  return join(dir, "graph.duckdb");
-}
-
-// ---------------------------------------------------------------------------
-// Fixtures — small, deterministic input sets covering both surfaces.
-// ---------------------------------------------------------------------------
-
-function fixtureCochanges(): readonly CochangeRow[] {
-  return [
-    {
-      sourceFile: "src/a.ts",
-      targetFile: "src/b.ts",
-      cocommitCount: 8,
-      totalCommitsSource: 10,
-      totalCommitsTarget: 12,
-      lastCocommitAt: "2026-01-01T00:00:00.000Z",
-      lift: 3.2,
-    },
-    {
-      sourceFile: "src/a.ts",
-      targetFile: "src/c.ts",
-      cocommitCount: 1,
-      totalCommitsSource: 10,
-      totalCommitsTarget: 50,
-      lastCocommitAt: "2026-01-02T00:00:00.000Z",
-      lift: 0.4,
-    },
-    {
-      sourceFile: "src/d.ts",
-      targetFile: "src/a.ts",
-      cocommitCount: 5,
-      totalCommitsSource: 7,
-      totalCommitsTarget: 10,
-      lastCocommitAt: "2026-01-03T00:00:00.000Z",
-      lift: 1.8,
-    },
-  ];
-}
-
-function fixtureSummaries(): readonly SymbolSummaryRow[] {
-  return [
-    {
-      nodeId: "Function:src/a.ts:alpha",
-      contentHash: "h1",
-      promptVersion: "1",
-      modelId: "anthropic.claude-haiku-4-5",
-      summaryText: "Do the alpha thing.",
-      signatureSummary: "(x: int) -> int",
-      returnsTypeSummary: "the alpha count",
-      createdAt: "2026-01-01T00:00:00.000Z",
-    },
-    {
-      nodeId: "Function:src/a.ts:alpha",
-      contentHash: "h1",
-      promptVersion: "2",
-      modelId: "anthropic.claude-haiku-4-5",
-      summaryText: "Do the alpha thing v2.",
-      createdAt: "2026-01-02T00:00:00.000Z",
-    },
-    {
-      nodeId: "Function:src/b.ts:beta",
-      contentHash: "h2",
-      promptVersion: "1",
-      modelId: "anthropic.claude-haiku-4-5",
-      summaryText: "Do the beta thing.",
-      createdAt: "2026-01-03T00:00:00.000Z",
-    },
-  ];
-}
-
-// ---------------------------------------------------------------------------
-// Helpers — load fixtures, snapshot the resulting state, normalise for parity
-// ---------------------------------------------------------------------------
-
-interface TemporalSnapshot {
-  readonly cochangesForA: readonly CochangeRow[];
-  readonly cochangesBetweenAB: CochangeRow | undefined;
-  readonly summaryAlphaV1: SymbolSummaryRow | undefined;
-  readonly summariesByNode: readonly SymbolSummaryRow[];
-}
-
-async function loadFixturesAndSnapshot(temporal: ITemporalStore): Promise<TemporalSnapshot> {
-  await temporal.bulkLoadCochanges(fixtureCochanges());
-  await temporal.bulkLoadSymbolSummaries(fixtureSummaries());
-  const cochangesForA = await temporal.lookupCochangesForFile("src/a.ts");
-  const cochangesBetweenAB = await temporal.lookupCochangesBetween("src/a.ts", "src/b.ts");
-  const summaryAlphaV1 = await temporal.lookupSymbolSummary("Function:src/a.ts:alpha", "h1", "1");
-  const summariesByNode = await temporal.lookupSymbolSummariesByNode([
-    "Function:src/a.ts:alpha",
-    "Function:src/b.ts:beta",
-  ]);
-  return { cochangesForA, cochangesBetweenAB, summaryAlphaV1, summariesByNode };
-}
-
-/**
- * Open a composed store, but only initialise its `temporal` view. The
- * graph view stays unopened — for the lbug backend that means the native
- * `@ladybugdb/core` binding is not required, since cochange + summary
- * data lives on the DuckDB-backed temporal store on every backend.
- */
-async function openTemporalOnly(
-  backend: "duck" | "lbug",
-  dbPath: string,
-): Promise<{ store: OpenStoreResult; temporal: ITemporalStore }> {
-  const store = await openStore({ path: dbPath, backend });
-  await store.temporal.open();
-  await store.temporal.createSchema();
-  return { store, temporal: store.temporal };
-}
-
-async function closeTemporalOnly(store: OpenStoreResult): Promise<void> {
-  // The lbug close() also closes the (unopened) graph adapter; that path
-  // is a no-op when the pool was never opened — see GraphDbStore.close().
-  await store.temporal.close();
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-test("temporal-parity: round-trip cochanges + summaries via openStore({backend:'duck'})", async () => {
-  const dbPath = await scratchDbPath("och-temporal-parity-duck-");
-  const { store, temporal } = await openTemporalOnly("duck", dbPath);
-  try {
-    const snapshot = await loadFixturesAndSnapshot(temporal);
-
-    // lookupCochangesForFile defaults: minLift=1.0 → drops the 0.4 row,
-    // sorts by lift DESC.
-    assert.equal(snapshot.cochangesForA.length, 2);
-    assert.equal(snapshot.cochangesForA[0]?.lift, 3.2);
-    assert.equal(snapshot.cochangesForA[0]?.targetFile, "src/b.ts");
-    assert.equal(snapshot.cochangesForA[1]?.sourceFile, "src/d.ts");
-
-    assert.ok(snapshot.cochangesBetweenAB);
-    assert.equal(snapshot.cochangesBetweenAB?.lift, 3.2);
-
-    assert.ok(snapshot.summaryAlphaV1);
-    assert.equal(snapshot.summaryAlphaV1?.summaryText, "Do the alpha thing.");
-    assert.equal(snapshot.summaryAlphaV1?.signatureSummary, "(x: int) -> int");
-
-    // (node_id ASC, prompt_version ASC, content_hash ASC) — three rows
-    // for the two requested nodes (alpha v1 + alpha v2 + beta v1).
-    assert.equal(snapshot.summariesByNode.length, 3);
-    assert.equal(snapshot.summariesByNode[0]?.nodeId, "Function:src/a.ts:alpha");
-    assert.equal(snapshot.summariesByNode[0]?.promptVersion, "1");
-    assert.equal(snapshot.summariesByNode[1]?.nodeId, "Function:src/a.ts:alpha");
-    assert.equal(snapshot.summariesByNode[1]?.promptVersion, "2");
-    assert.equal(snapshot.summariesByNode[2]?.nodeId, "Function:src/b.ts:beta");
-  } finally {
-    await closeTemporalOnly(store);
-  }
-});
-
-test("temporal-parity: round-trip cochanges + summaries via openStore({backend:'lbug'})", async () => {
-  const dbPath = await scratchDbPath("och-temporal-parity-lbug-");
-  const { store, temporal } = await openTemporalOnly("lbug", dbPath);
-  try {
-    const snapshot = await loadFixturesAndSnapshot(temporal);
-
-    assert.equal(snapshot.cochangesForA.length, 2);
-    assert.equal(snapshot.cochangesForA[0]?.lift, 3.2);
-    assert.ok(snapshot.cochangesBetweenAB);
-    assert.equal(snapshot.cochangesBetweenAB?.lift, 3.2);
-    assert.ok(snapshot.summaryAlphaV1);
-    assert.equal(snapshot.summaryAlphaV1?.summaryText, "Do the alpha thing.");
-    assert.equal(snapshot.summariesByNode.length, 3);
-  } finally {
-    await closeTemporalOnly(store);
-  }
-});
-
-test("temporal-parity: openStore composes identical temporal snapshots across backends", async () => {
-  const duckPath = await scratchDbPath("och-temporal-parity-cross-duck-");
-  const lbugPath = await scratchDbPath("och-temporal-parity-cross-lbug-");
-
-  const { store: duckStore, temporal: duckTemporal } = await openTemporalOnly("duck", duckPath);
-  const { store: lbugStore, temporal: lbugTemporal } = await openTemporalOnly("lbug", lbugPath);
-
-  try {
-    const a = await loadFixturesAndSnapshot(duckTemporal);
-    const b = await loadFixturesAndSnapshot(lbugTemporal);
-
-    // The two backends route ITemporalStore through DuckDbStore — every
-    // method returns identical values for identical inputs. JSON round-
-    // trip pins the equality across the readonly + spread shapes vitest
-    // would otherwise treat as deeply distinct.
-    assert.deepStrictEqual(JSON.parse(JSON.stringify(a)), JSON.parse(JSON.stringify(b)));
-  } finally {
-    await closeTemporalOnly(duckStore);
-    await closeTemporalOnly(lbugStore);
-  }
-});
-
-test("openStore({backend:'lbug'}) splits artifacts into graph.lbug + temporal.duckdb siblings", async () => {
-  // The temporal store lives at <dir>/temporal.duckdb, the graph store
-  // at <dir>/graph.lbug, regardless of the legacy filename the caller
-  // passes through.
-  const dbPath = await scratchDbPath("och-temporal-parity-paths-");
-  const store = await openStore({ path: dbPath, backend: "lbug" });
-  try {
-    const dir = join(dbPath, "..");
-    assert.equal(store.graphFile, join(dir, "graph.lbug"));
-    assert.equal(store.temporalFile, join(dir, "temporal.duckdb"));
-    assert.notEqual(store.graphFile, store.temporalFile);
-  } finally {
-    // Neither view was opened — close() is a no-op on each adapter.
-    await store.close();
-  }
-});
-
-test("openStore({backend:'duck'}) collapses graph + temporal to the same DuckDB connection", async () => {
-  const dbPath = await scratchDbPath("och-temporal-parity-duck-paths-");
-  const store = await openStore({ path: dbPath, backend: "duck" });
-  try {
-    assert.equal(store.graphFile, dbPath);
-    assert.equal(store.temporalFile, dbPath);
-    // Identity equality — the same DuckDbStore instance fronts both views.
-    assert.equal(store.graph as unknown, store.temporal as unknown);
-  } finally {
-    await store.close();
-  }
-});
diff --git a/packages/wiki/src/index.test.ts b/packages/wiki/src/index.test.ts
index 687b8754..c8174cc3 100644
--- a/packages/wiki/src/index.test.ts
+++ b/packages/wiki/src/index.test.ts
@@ -211,7 +211,7 @@ function projectEdge(e: WikiEdge): CodeRelation {
 }
 
 class WikiFakeStore implements IGraphStore {
-  readonly dialect: GraphDialect = "none";
+  readonly dialect: GraphDialect = "cypher";
   readonly nodes: WikiNode[] = [];
   readonly edges: WikiEdge[] = [];