From 160d655dc03f3a410f4fe79976614dee340373b3 Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Tue, 14 Jul 2026 14:09:59 -0400
Subject: [PATCH 01/32] feat(neo4j): declare TS twin-label vocabulary, schema
 1.1.0 (#65)

---
 schema.neo4j.json         | 22 ++++++++++++++++++--
 src/build/neo4j/index.ts  |  2 +-
 src/build/neo4j/schema.ts | 35 ++++++++++++++++++++++++++++++-
 test/neo4j-twins.test.ts  | 44 +++++++++++++++++++++++++++++++++++++++
 4 files changed, 99 insertions(+), 4 deletions(-)
 create mode 100644 test/neo4j-twins.test.ts

diff --git a/schema.neo4j.json b/schema.neo4j.json
index fcc80bb..c10af05 100644
--- a/schema.neo4j.json
+++ b/schema.neo4j.json
@@ -1,5 +1,5 @@
 {
-  "schema_version": "1.0.0",
+  "schema_version": "1.1.0",
   "generator": "codeanalyzer-typescript",
   "marker_labels": [
     "Entrypoint"
@@ -456,5 +456,23 @@
     "CREATE INDEX callable_name IF NOT EXISTS FOR (c:Callable) ON (c.name)",
     "CREATE INDEX decorator_name IF NOT EXISTS FOR (d:Decorator) ON (d.name)",
     "CREATE FULLTEXT INDEX code_fts IF NOT EXISTS FOR (c:Callable) ON EACH [c.code, c.docstring]"
-  ]
+  ],
+  "label_twins": {
+    "Application": "TSApplication",
+    "Module": "TSModule",
+    "Class": "TSClass",
+    "Interface": "TSInterface",
+    "Enum": "TSEnum",
+    "TypeAlias": "TSTypeAlias",
+    "Namespace": "TSNamespace",
+    "Callable": "TSCallable",
+    "External": "TSExternal",
+    "AnonymousCallable": "TSAnonymousCallable",
+    "Package": "TSPackage",
+    "Decorator": "TSDecorator",
+    "CallSite": "TSCallSite",
+    "Attribute": "TSAttribute",
+    "Variable": "TSVariable",
+    "Entrypoint": "TSEntrypoint"
+  }
 }
diff --git a/src/build/neo4j/index.ts b/src/build/neo4j/index.ts
index 3fadc2f..be460ec 100644
--- a/src/build/neo4j/index.ts
+++ b/src/build/neo4j/index.ts
@@ -3,6 +3,6 @@
 export { project } from "./project";
 export { renderCypher } from "./cypher";
 export { boltWriter, type BoltConfig } from "./bolt";
-export { SCHEMA_VERSION, buildSchemaDocument, NODE_LABELS, REL_TYPES, MARKER_LABELS } from "./schema";
+export { SCHEMA_VERSION, TS_PREFIX, twinOf, withTwins, buildSchemaDocument, NODE_LABELS, REL_TYPES, MARKER_LABELS } from "./schema";
 export type { SchemaDocument } from "./schema";
 export type { GraphRows, NodeRow, EdgeRow } from "./rows";
diff --git a/src/build/neo4j/schema.ts b/src/build/neo4j/schema.ts
index 834a19f..b77e184 100644
--- a/src/build/neo4j/schema.ts
+++ b/src/build/neo4j/schema.ts
@@ -13,7 +13,7 @@
  * the :Application node of every emitted graph so any consumer can detect a producer/consumer
  * mismatch at runtime.
  */
-export const SCHEMA_VERSION = "1.0.0";
+export const SCHEMA_VERSION = "1.1.0";
 
 export type PropType = "string" | "integer" | "float" | "boolean" | "string[]" | "integer[]";
 
@@ -36,6 +36,28 @@ export interface RelType {
 /** Labels layered onto a node in addition to its primary/specific label. */
 export const MARKER_LABELS = ["Entrypoint"] as const;
 
+/**
+ * Language-namespace twins (schema 1.1.0, additive): every specific and marker label is also
+ * stamped as `TS<Label>` so a shared multi-language database can attribute TS nodes (epic #64,
+ * issue #65). The shared merge label `Symbol` deliberately has NO twin — MERGE targets, keys and
+ * constraints are unchanged. The bare labels drop (and rel types gain `TS_`) in schema 2.0.0.
+ */
+export const TS_PREFIX = "TS";
+
+/** The TS-prefixed twin of a specific or marker label. */
+export const twinOf = (label: string): string => `${TS_PREFIX}${label}`;
+
+/** Expand a projection label set with its twins: order preserved, `Symbol` skipped, idempotent. */
+export function withTwins(labels: string[]): string[] {
+  const out = [...labels];
+  for (const l of labels) {
+    if (l === "Symbol" || l.startsWith(TS_PREFIX)) continue;
+    const t = twinOf(l);
+    if (!out.includes(t)) out.push(t);
+  }
+  return out;
+}
+
 const SPAN = { start_line: "integer", end_line: "integer" } as const;
 const ENTRYPOINT = {
   framework: "string",
@@ -349,6 +371,16 @@ export interface SchemaDocument {
   relationship_types: RelType[];
   constraints: readonly string[];
   indexes: readonly string[];
+  /** Specific/marker label → its TS-prefixed twin (both are present on every emitted node). */
+  label_twins: Record<string, string>;
+}
+
+/** One twin per specific label + per marker label — derived from the catalogs, never drifts. */
+function labelTwins(): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const n of NODE_LABELS) out[n.label] = twinOf(n.label);
+  for (const m of MARKER_LABELS) out[m] = twinOf(m);
+  return out;
 }
 
 /** Build the full machine-readable schema document emitted by `--emit schema`. */
@@ -361,5 +393,6 @@ export function buildSchemaDocument(): SchemaDocument {
     relationship_types: REL_TYPES,
     constraints: CONSTRAINTS,
     indexes: INDEXES,
+    label_twins: labelTwins(),
   };
 }
diff --git a/test/neo4j-twins.test.ts b/test/neo4j-twins.test.ts
new file mode 100644
index 0000000..62db1a5
--- /dev/null
+++ b/test/neo4j-twins.test.ts
@@ -0,0 +1,44 @@
+/**
+ * Twin-label vocabulary (graph schema 1.1.0, issue #65): every specific and marker label has a
+ * TS-prefixed twin; the shared merge label `Symbol` deliberately has none (epic #64).
+ */
+import { describe, expect, test } from "bun:test";
+import {
+  MARKER_LABELS,
+  NODE_LABELS,
+  SCHEMA_VERSION,
+  TS_PREFIX,
+  buildSchemaDocument,
+  twinOf,
+  withTwins,
+} from "../src/build/neo4j";
+
+describe("TS twin-label vocabulary", () => {
+  test("twinOf prefixes with TS", () => {
+    expect(TS_PREFIX).toBe("TS");
+    expect(twinOf("Callable")).toBe("TSCallable");
+    expect(twinOf("Entrypoint")).toBe("TSEntrypoint");
+  });
+
+  test("withTwins appends a twin per label, keeps order, and skips Symbol", () => {
+    expect(withTwins(["Module"])).toEqual(["Module", "TSModule"]);
+    expect(withTwins(["Symbol", "Class"])).toEqual(["Symbol", "Class", "TSClass"]);
+    expect(withTwins(["Symbol", "Callable", "Entrypoint"])).toEqual([
+      "Symbol", "Callable", "Entrypoint", "TSCallable", "TSEntrypoint",
+    ]);
+    // idempotent: an already-expanded set gains nothing
+    expect(withTwins(["Module", "TSModule"])).toEqual(["Module", "TSModule"]);
+  });
+
+  test("schema version is 1.1.0 (additive MINOR)", () => {
+    expect(SCHEMA_VERSION).toBe("1.1.0");
+  });
+
+  test("schema document maps every specific + marker label to its twin", () => {
+    const doc = buildSchemaDocument();
+    for (const n of NODE_LABELS) expect(doc.label_twins[n.label]).toBe(twinOf(n.label));
+    for (const m of MARKER_LABELS) expect(doc.label_twins[m]).toBe(twinOf(m));
+    expect(doc.label_twins["Symbol"]).toBeUndefined();
+    expect(Object.keys(doc.label_twins).length).toBe(NODE_LABELS.length + MARKER_LABELS.length);
+  });
+});

From 4b054b45d20ffd88836333ae37bd8247bfa47e83 Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Tue, 14 Jul 2026 14:16:29 -0400
Subject: [PATCH 02/32] feat(neo4j): stamp TS twin labels on every projected
 node (#65)

---
 src/build/neo4j/project.ts | Bin 19788 -> 19808 bytes
 src/build/neo4j/rows.ts    | Bin 5601 -> 5952 bytes
 test/neo4j-schema.test.ts  |  28 +++++++++++++++++++++++++---
 3 files changed, 25 insertions(+), 3 deletions(-)

diff --git a/src/build/neo4j/project.ts b/src/build/neo4j/project.ts
index 6cbbde0e0686216d9ff93df29e60feb344540e2f..d112d3d78100fa1bda727f11eb45019ebe6add4f 100644
GIT binary patch
delta 41
ocmX>zi}ArM#tq&q+&T*7nI#z^<(YZKo4r|TnK%*L6KpMR07xniumAu6

delta 19
bcmaDbi}B1X#tq&qo5NUYnKs{HYjFbrQ}zeV

diff --git a/src/build/neo4j/rows.ts b/src/build/neo4j/rows.ts
index 50195ff97315fc8563586a0210ef9e32c4deabe8..73d085a30ff19c0f6611709bb58cd3e90ff3ce38 100644
GIT binary patch
delta 354
zcmX|7yG{f#3>4jgC}=5=reha$3!=Q!A%1`_KolWsb_3ZYihYk2LibBZS0ho=@d^A1
zxy_2gmh2hN*#5ozsy@Ca+q<Bm>Oh;ITn!(@c&99^dLlbzk`bW@6@oQXLp*3jv4`_D
zopYu#3TX+fTk2G5^%Rc)T)?;&(!ww)WNqAZP)6|9=pOBsBFz!~nyXAA`wSM<^Qbjd
zjq@x<mlf`pEO;dfNM2dKqu5Yh0ZNivO&eTS19+9P_KqbkwfI<sXjV!HkyP!S?f0kM
zq^oBrhNXCxoTG8g!()lX?SFwqA`G3B-`;nhlhcE<Jdq%24OjVnqf9y9{T!Yg{{i4r
Bdba=o

delta 17
YcmX@0_fUJoDUQwTTs(}MO}V*w06upGSO5S3

diff --git a/test/neo4j-schema.test.ts b/test/neo4j-schema.test.ts
index 6cbf4c1..8f56659 100644
--- a/test/neo4j-schema.test.ts
+++ b/test/neo4j-schema.test.ts
@@ -15,6 +15,8 @@ import {
   REL_TYPES,
   buildSchemaDocument,
   project,
+  twinOf,
+  withTwins,
 } from "../src/build/neo4j";
 import { analyze } from "../src/core";
 import type { AnalysisOptions } from "../src/options";
@@ -40,13 +42,17 @@ const byLabel = new Map(NODE_LABELS.map((n) => [n.label, n]));
 const mergeOf = new Map(NODE_LABELS.map((n) => [n.label, n.mergeLabel]));
 const relByType = new Map(REL_TYPES.map((r) => [r.type, r]));
 const markers = new Set<string>(MARKER_LABELS);
+const twins = new Set<string>([
+  ...NODE_LABELS.map((n) => twinOf(n.label)),
+  ...MARKER_LABELS.map((m) => twinOf(m)),
+]);
 const mergeLabelsFor = (specifics: string[]) => new Set(specifics.map((s) => mergeOf.get(s)));
 
-/** The specific (schema) label for a node row: the non-merge, non-marker label. */
+/** The specific (schema) label for a node row: the non-merge, non-marker, non-twin label. */
 function specificLabel(labels: string[]): string {
   const merge = labels[0];
   if (merge !== "Symbol") return merge;
-  return labels.find((l) => l !== "Symbol" && !markers.has(l)) ?? "Symbol";
+  return labels.find((l) => l !== "Symbol" && !markers.has(l) && !twins.has(l)) ?? "Symbol";
 }
 
 describe("neo4j schema conformance", () => {
@@ -60,7 +66,7 @@ describe("neo4j schema conformance", () => {
       expect(node.labels[0]).toBe(decl!.mergeLabel);
 
       for (const label of node.labels) {
-        const ok = label === decl!.mergeLabel || label === specific || markers.has(label);
+        const ok = label === decl!.mergeLabel || label === specific || markers.has(label) || twins.has(label);
         expect(ok, `unexpected label '${label}' on ${specific}`).toBe(true);
       }
       for (const key of Object.keys(node.props)) {
@@ -86,4 +92,20 @@ describe("neo4j schema conformance", () => {
     const fresh = JSON.stringify(buildSchemaDocument(), null, 2).trim();
     expect(onDisk).toBe(fresh);
   });
+
+  test("every node carries exactly the TS twins of its base labels (1.1.0 dual-labeling)", () => {
+    for (const node of rows.nodes) {
+      const base = node.labels.filter((l) => !twins.has(l));
+      expect(new Set(node.labels), `bad twin set on ${node.labels.join(":")} ${node.value}`).toEqual(
+        new Set(withTwins(base)),
+      );
+      expect(twins.has(node.labels[0]), `merge label must stay bare: ${node.labels[0]}`).toBe(false);
+    }
+  });
+
+  test(":Application is stamped with the 1.1.0 contract version", () => {
+    const app = rows.nodes.find((n) => n.labels[0] === "Application");
+    expect(app).toBeDefined();
+    expect(app!.props.schema_version).toBe("1.1.0");
+  });
 });

From c9a27963d61fb480c0be7c730090a409c722a62e Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Tue, 14 Jul 2026 14:26:44 -0400
Subject: [PATCH 03/32] docs(neo4j): document the TS-prefix guard that makes
 withTwins idempotent (#65)

---
 src/build/neo4j/schema.ts | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/build/neo4j/schema.ts b/src/build/neo4j/schema.ts
index b77e184..76a5ce5 100644
--- a/src/build/neo4j/schema.ts
+++ b/src/build/neo4j/schema.ts
@@ -47,7 +47,11 @@ export const TS_PREFIX = "TS";
 /** The TS-prefixed twin of a specific or marker label. */
 export const twinOf = (label: string): string => `${TS_PREFIX}${label}`;
 
-/** Expand a projection label set with its twins: order preserved, `Symbol` skipped, idempotent. */
+/**
+ * Expand a projection label set with its twins: order preserved, `Symbol` skipped, idempotent.
+ * Any label already starting with `TS` is treated as a twin and never re-prefixed — so no bare
+ * label may legitimately begin with `TS`.
+ */
 export function withTwins(labels: string[]): string[] {
   const out = [...labels];
   for (const l of labels) {

From 834ed1611896ef6ac36f3b2bffd507cbc67c9553 Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Tue, 14 Jul 2026 21:07:49 -0400
Subject: [PATCH 04/32] chore(release): 0.5.0

---
 package.json         | 2 +-
 src/utils/version.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/package.json b/package.json
index b3b15e2..6c13526 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "codeanalyzer-typescript",
-  "version": "0.4.3",
+  "version": "0.5.0",
   "description": "CLDK TypeScript analyzer — emits the canonical CLDK analysis.json (symbol table + resolver-based call graph) via ts-morph.",
   "type": "module",
   "module": "src/index.ts",
diff --git a/src/utils/version.ts b/src/utils/version.ts
index d2cd3e6..c33aa41 100644
--- a/src/utils/version.ts
+++ b/src/utils/version.ts
@@ -3,4 +3,4 @@
  * the analyzer invalidates stale per-file Modules (whose source is unchanged but whose extracted
  * shape may differ across analyzer versions).
  */
-export const ANALYZER_VERSION = "0.1.0";
+export const ANALYZER_VERSION = "0.5.0";

From f150c2588b7e52fdffcef54bf36beeb5cf9f1af1 Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Wed, 1 Jul 2026 21:45:42 -0400
Subject: [PATCH 05/32] =?UTF-8?q?feat:=20add=20level-3=20program=20graphs?=
 =?UTF-8?q?=20=E2=80=94=20native=20CFG/PDG/SDG=20and=20backward=20slicing?=
 =?UTF-8?q?=20(-a=203)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Implements the dataflow half of #2: whole-program dependence graphs built
in-process from the ts-morph AST, emitted as a schema-versioned
program_graphs section of analysis.json, gated by -a 3 / --graphs.

- src/dataflow/cfg.ts: exceptional statement-level CFG per callable
  (ENTRY/param/statement/EXIT nodes in source-span order; true/false,
  loop_back, switch_case, exception, await_resume, yield edge kinds;
  region-spliced try/catch/finally; synthetic loop-exit edge keeps EXIT
  the post-dominance root).
- src/dataflow/dominance.ts: CHK iterative post-dominators +
  Ferrante–Ottenstein–Warren control dependence (CDG).
- src/dataflow/defuse.ts: k-limited access paths (declaration-keyed bases:
  local/param/this/captured/module), copy-alias union-find MVP, forward
  reaching definitions, DDG extraction, capture-at-declaration for
  closures, EXIT-as-formal-out routing.
- src/dataflow/summaries.ts: Tarjan SCC condensation of the
  provenance-merged call graph; bottom-up relational summaries
  (param→return, transitive global reads/writes) co-defined to a monotone
  fixpoint inside SCCs; persisted with dependency edges to
  graphs_summaries.json for later incrementality.
- src/dataflow/sdg.ts: HRB stitching — CALL, PARAM_IN (args by position,
  globals as extra params), PARAM_OUT, and SUMMARY edges, all keyed by
  (signature, node_id) with no dangling endpoints.
- src/dataflow/slice.ts: two-phase context-sensitive backward slicing as
  an SDG query.
- CLI: -a 3, --graphs cfg,dfg,pdg,sdg, --graph-field-depth (strictly
  validated); -a 1/-a 2 are untouched (level 3 is fully flag-gated).
- test/fixtures/dataflow-app + test/dataflow.test.ts: every contract gate
  with exact hand-computed expected sets (CFG reachability, CDG sets,
  loop-carried/shadowing/aliasing DDG, intraprocedural and
  interprocedural slices, SUMMARY for the a→b→c chain, global flow,
  mutual-recursion fixpoint, byte-identical determinism).

Follow-ups staged in #2: taint models-as-data (PR E), Jelly points-to
aliasing (PR F), CPG Neo4j projection (PR G), incremental re-analysis
(PR H).
---
 CLAUDE.md                                  |  16 +-
 README.md                                  |  53 +-
 src/cli.ts                                 |  43 +-
 src/core.ts                                |   8 +
 src/dataflow/cfg.ts                        | 482 ++++++++++++++++
 src/dataflow/defuse.ts                     | 631 +++++++++++++++++++++
 src/dataflow/dominance.ts                  | 140 +++++
 src/dataflow/index.ts                      | 259 +++++++++
 src/dataflow/model.ts                      |  44 ++
 src/dataflow/sdg.ts                        | 120 ++++
 src/dataflow/slice.ts                      |  69 +++
 src/dataflow/summaries.ts                  | 237 ++++++++
 src/options/options.ts                     |  13 +-
 src/schema/graphs.ts                       | 131 +++++
 src/schema/index.ts                        |   1 +
 src/schema/schema.ts                       |   2 +
 test/dataflow.test.ts                      | 413 ++++++++++++++
 test/fixtures/dataflow-app/package.json    |   6 +
 test/fixtures/dataflow-app/src/chain.ts    |  30 +
 test/fixtures/dataflow-app/src/closures.ts |  17 +
 test/fixtures/dataflow-app/src/flow.ts     |  86 +++
 test/fixtures/dataflow-app/src/main.ts     |   9 +
 test/fixtures/dataflow-app/src/state.ts    |  16 +
 test/fixtures/dataflow-app/src/susp.ts     |  25 +
 test/fixtures/dataflow-app/src/taint.ts    |  26 +
 test/fixtures/dataflow-app/src/util.ts     |   3 +
 test/fixtures/dataflow-app/tsconfig.json   |  10 +
 test/neo4j-bolt.test.ts                    |   2 +
 test/neo4j-schema.test.ts                  |   2 +-
 29 files changed, 2882 insertions(+), 12 deletions(-)
 create mode 100644 src/dataflow/cfg.ts
 create mode 100644 src/dataflow/defuse.ts
 create mode 100644 src/dataflow/dominance.ts
 create mode 100644 src/dataflow/index.ts
 create mode 100644 src/dataflow/model.ts
 create mode 100644 src/dataflow/sdg.ts
 create mode 100644 src/dataflow/slice.ts
 create mode 100644 src/dataflow/summaries.ts
 create mode 100644 src/schema/graphs.ts
 create mode 100644 test/dataflow.test.ts
 create mode 100644 test/fixtures/dataflow-app/package.json
 create mode 100644 test/fixtures/dataflow-app/src/chain.ts
 create mode 100644 test/fixtures/dataflow-app/src/closures.ts
 create mode 100644 test/fixtures/dataflow-app/src/flow.ts
 create mode 100644 test/fixtures/dataflow-app/src/main.ts
 create mode 100644 test/fixtures/dataflow-app/src/state.ts
 create mode 100644 test/fixtures/dataflow-app/src/susp.ts
 create mode 100644 test/fixtures/dataflow-app/src/taint.ts
 create mode 100644 test/fixtures/dataflow-app/src/util.ts
 create mode 100644 test/fixtures/dataflow-app/tsconfig.json

diff --git a/CLAUDE.md b/CLAUDE.md
index c27c626..311b536 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -29,9 +29,14 @@ it first; everything else is a stage it calls, in order:
    JSDoc, with precise source spans.
 3. **call graph** (`src/semantic_analysis`) — `selectProvider()` picks tsc / jelly /
    union; each provider returns edges + external (phantom) symbols.
-4. **cache** (`src/utils/cache.ts`) — content-hash cache under `.codeanalyzer/`, so
-   re-analysis only touches what changed.
-5. **output** (`src/build`, `src/build/neo4j`) — `analysis.json`, a self-contained
+4. **program graphs** (`src/dataflow`) — level 3 only (`-a 3`): CFG → post-dominance/CDG →
+   access-path def-use → PDG → SCC-condensed bottom-up summaries → SDG, emitted as the
+   `program_graphs` section keyed by `(signature, node_id)`. Decisions: the "Level 3"
+   half of `.claude/SCHEMA_DECISIONS.md`; contract + staged follow-ups: issue #2.
+5. **cache** (`src/utils/cache.ts`) — content-hash cache under `.codeanalyzer/`, so
+   re-analysis only touches what changed (level 3 also records summaries +
+   dependency edges in `graphs_summaries.json`).
+6. **output** (`src/build`, `src/build/neo4j`) — `analysis.json`, a self-contained
    `graph.cypher` snapshot, or an incremental Bolt push to a live database.
 
 The shape of everything is the **schema** in `src/schema` (`TSApplication` is the top
@@ -47,10 +52,11 @@ a contract.
 | `src/options` | Parsed CLI options / `AnalysisOptions` |
 | `src/syntactic_analysis` | Symbol table (ts-morph traversal) |
 | `src/semantic_analysis` | Call-graph providers (tsc, jelly, union), phantoms |
-| `src/schema` | `TSApplication` types + signatures (the output contract) |
+| `src/dataflow` | Level-3 program graphs: CFG, dominance/CDG, def-use, summaries, SDG, slicing |
+| `src/schema` | `TSApplication` types + signatures + `program_graphs` (the output contract) |
 | `src/build` | Dep materialization + output; `build/neo4j` = graph projection |
 | `src/utils` | fs, caching, logging, serialization, version |
-| `test` | Bun tests + `fixtures/sample-app` |
+| `test` | Bun tests + `fixtures/sample-app` (levels 1–2) + `fixtures/dataflow-app` (level-3 gates) |
 
 ## Commands
 
diff --git a/README.md b/README.md
index 5646c55..586cf0e 100644
--- a/README.md
+++ b/README.md
@@ -158,8 +158,13 @@ Options:
                                  (default: "neo4j", env: NEO4J_PASSWORD)
   --neo4j-database <db>          Neo4j database name (env: NEO4J_DATABASE)
   -a, --analysis-level <n>       analysis depth: 1 = symbol table + tsc resolver
-                                 call graph + RTA (default); 2 = call graph
-                                 (default: "1")
+                                 call graph + RTA (default); 2 = call graph; 3 =
+                                 + program graphs (CFG/PDG/SDG) (default: "1")
+  --graphs <list>                level-3 graph sections to emit,
+                                 comma-separated: cfg | dfg | pdg | sdg
+                                 (default: all; requires -a 3)
+  --graph-field-depth <k>        access-path depth bound (k-limit) for level-3
+                                 dataflow (default: "3")
   -t, --target-files <paths...>  restrict analysis to specific files
                                  (incremental)
   --skip-tests                   skip test trees (default)
@@ -213,6 +218,12 @@ Options:
    cants --input ./my-ts-project --eager --cache-dir /path/to/custom-cache
    ```
 
+6. **Program graphs (level 3): CFG/PDG/SDG in `analysis.json`:**
+   ```sh
+   cants --input ./my-ts-project -a 3                    # full program_graphs section
+   cants --input ./my-ts-project -a 3 --graphs cfg,pdg   # scope the emitted graphs
+   ```
+
 ## Output targets
 
 `cants` builds one analysis in memory and can emit it three ways (`--emit`):
@@ -234,6 +245,44 @@ A `TSApplication` document — the canonical CLDK contract the Python SDK parses
 Caller- and callee-side identifiers come from a single signature canonicalizer, so call-graph
 `source`/`target` values byte-match the corresponding `symbol_table` / `external_symbols` keys.
 
+### Program graphs (`-a 3`)
+
+`--analysis-level 3` adds a `program_graphs` section to `analysis.json` — native, whole-program
+dependence graphs built in-process from the same ts-morph AST (no external engine), per the CLDK
+level-3 dataflow contract:
+
+```jsonc
+{
+  "program_graphs": {
+    "schema_version": "1.0.0",
+    "k_limit": 3,                    // access-path depth bound (--graph-field-depth)
+    "functions": {
+      "<signature>": {
+        "cfg": { "nodes": [...], "edges": [...] },   // exceptional control-flow graph
+        "pdg": { "edges": [...] }                    // CDG (control) + DDG (data) dependence
+      }
+    },
+    "sdg_edges": [ /* cross-function CALL / PARAM_IN / PARAM_OUT / SUMMARY edges */ ]
+  }
+}
+```
+
+Every graph node is keyed by `(signature, node_id)` — the same signature canonicalizer as the
+symbol table and call graph — so graphs, call edges, and callables all join. `--graphs
+cfg,dfg,pdg,sdg` scopes the emitted sections (default: all).
+
+**Substrate (locked in [issue #2](https://github.com/codellm-devkit/codeanalyzer-typescript/issues/2)):**
+the CFG and reaching-definitions are hand-built from the ts-morph AST; the call-graph oracle is
+the existing provenance-merged tsc ∪ Jelly graph; aliasing is a flow-insensitive copy-alias MVP
+(Jelly points-to-backed propagation is a staged upgrade). Function summaries are composed
+bottom-up over the SCC condensation of the call graph, with k-limited access paths; module
+globals ride the SDG as extra parameters. The analysis is deliberately sound-leaning and
+over-approximate; known unsoundness (dynamic `eval`, reflection/monkey-patching, npm-internal
+effects) is recorded in `.claude/SCHEMA_DECISIONS.md`. Backward slicing and taint run as queries
+over the SDG (slicing ships now inside the analyzer; the configurable taint pack is staged).
+
+Levels 1/2 are unaffected: nothing in level 3 runs unless `-a 3` is requested.
+
 ### Neo4j graph
 
 `--emit neo4j` projects the same analysis into a labeled property graph (declarations keyed by
diff --git a/src/cli.ts b/src/cli.ts
index fba5dd4..4df7fe3 100644
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -1,6 +1,7 @@
 import * as path from "node:path";
 import { Command, Option } from "commander";
 import type { AnalysisOptions, CallGraphProviderName, EmitTarget } from "./options";
+import { ALL_GRAPHS, type GraphSelector } from "./schema";
 
 /**
  * Build the commander program. Shared by parseArgs and by the README generator
@@ -35,7 +36,16 @@ export function buildProgram(): Command {
         .default("neo4j"),
     )
     .addOption(new Option("--neo4j-database <db>", "Neo4j database name").env("NEO4J_DATABASE"))
-    .option("-a, --analysis-level <n>", "analysis depth: 1 = symbol table + tsc resolver call graph + RTA (default); 2 = call graph", "1")
+    .option(
+      "-a, --analysis-level <n>",
+      "analysis depth: 1 = symbol table + tsc resolver call graph + RTA (default); 2 = call graph; 3 = + program graphs (CFG/PDG/SDG)",
+      "1",
+    )
+    .option(
+      "--graphs <list>",
+      "level-3 graph sections to emit, comma-separated: cfg | dfg | pdg | sdg (default: all; requires -a 3)",
+    )
+    .option("--graph-field-depth <k>", "access-path depth bound (k-limit) for level-3 dataflow", "3")
     .option("-t, --target-files <paths...>", "restrict analysis to specific files (incremental)")
     .option("--skip-tests", "skip test trees (default)")
     .option("--include-tests", "include test trees")
@@ -61,7 +71,34 @@ export function parseArgs(argv: string[]): AnalysisOptions {
   program.parse(argv, { from: "user" });
   const o = program.opts();
 
-  const level = String(o.analysisLevel) === "2" ? 2 : 1;
+  const levelStr = String(o.analysisLevel);
+  if (!["1", "2", "3"].includes(levelStr)) {
+    program.error(`error: invalid --analysis-level '${levelStr}' (expected 1, 2, or 3)`);
+  }
+  const level = Number(levelStr) as 1 | 2 | 3;
+
+  // --graphs: strict validation (never a silent fallback), and only meaningful at -a 3.
+  let graphs: GraphSelector[] = [...ALL_GRAPHS];
+  if (o.graphs !== undefined) {
+    if (level !== 3) program.error("error: --graphs requires --analysis-level 3");
+    const requested = String(o.graphs)
+      .split(",")
+      .map((g) => g.trim())
+      .filter((g) => g.length > 0);
+    if (!requested.length) program.error("error: --graphs requires at least one of: cfg, dfg, pdg, sdg");
+    for (const g of requested) {
+      if (!(ALL_GRAPHS as string[]).includes(g)) {
+        program.error(`error: unknown --graphs value '${g}' (expected: cfg, dfg, pdg, sdg)`);
+      }
+    }
+    graphs = [...new Set(requested)] as GraphSelector[];
+  }
+
+  const kStr = String(o.graphFieldDepth);
+  const k = Number(kStr);
+  if (!Number.isInteger(k) || k < 1) {
+    program.error(`error: invalid --graph-field-depth '${kStr}' (expected a positive integer)`);
+  }
   const emit: EmitTarget = o.emit === "neo4j" ? "neo4j" : o.emit === "schema" ? "schema" : "json";
   // --emit schema is a static artifact and needs no project; every other target requires -i.
   if (emit !== "schema" && !o.input) program.error("required option '-i, --input <path>' not specified");
@@ -94,6 +131,8 @@ export function parseArgs(argv: string[]): AnalysisOptions {
     neo4jPassword: String(o.neo4jPassword),
     neo4jDatabase: o.neo4jDatabase ? String(o.neo4jDatabase) : null,
     analysisLevel: level,
+    graphs,
+    graphFieldDepth: k,
     targetFiles: targets,
     skipTests: o.includeTests ? false : true,
     eager: Boolean(o.eager),
diff --git a/src/core.ts b/src/core.ts
index 85e768a..372360f 100644
--- a/src/core.ts
+++ b/src/core.ts
@@ -1,4 +1,5 @@
 import * as path from "node:path";
+import { buildProgramGraphs } from "./dataflow";
 import { selectProvider } from "./semantic_analysis";
 import { loadCache, saveCache } from "./utils";
 import { materialize } from "./build";
@@ -34,6 +35,13 @@ export function analyze(opts: AnalysisOptions): TSApplication {
     external_symbols: cg.external_symbols,
     synthesized_callables: cg.synthesized_callables,
   };
+
+  // Level 3: native program graphs (CFG/PDG/SDG). Strictly flag-gated so -a 1/-a 2 cost nothing;
+  // runs after the call graph because the SDG consumes its backfilled callee signatures.
+  if (opts.analysisLevel === 3) {
+    app.program_graphs = buildProgramGraphs({ project, symbol_table, opts, log });
+  }
+
   saveCache(cacheDir, { symbol_table, call_graph });
   return app;
 }
diff --git a/src/dataflow/cfg.ts b/src/dataflow/cfg.ts
new file mode 100644
index 0000000..a8200d0
--- /dev/null
+++ b/src/dataflow/cfg.ts
@@ -0,0 +1,482 @@
+/**
+ * Stage 1 — exceptional CFG per callable, lowered directly from the ts-morph AST.
+ *
+ * Shape: statement-level nodes plus one `param` node per formal, between a synthetic ENTRY (id 0)
+ * and a synthetic EXIT (last id). Node ids are the source-span order of the owning AST nodes
+ * within the callable, so they are stable across runs on identical content.
+ *
+ * TS lowering rules (each asserted by the fixture gate tests):
+ *  - if/loops/switch: the control statement itself is the condition-carrying node; branches get
+ *    `true`/`false` edges, the loop back edge is `loop_back`, switch dispatch is `switch_case`
+ *    (clause fallthrough between non-terminated clauses is `fallthrough`).
+ *  - A `for` node carries its init/condition/incrementor as one node; `for-of`/`for-in` nodes
+ *    bind the iteration variable.
+ *  - Multi-exit is normalized: `return` → EXIT (`return` edge), fall-off-end → EXIT
+ *    (`fallthrough`), `throw` → nearest enclosing handler or EXIT (`exception`).
+ *  - Exceptional edges are over-approximate: every node whose expression contains a call / `new` /
+ *    `await` / tagged template — and every `throw` — gets an `exception` edge to the nearest
+ *    enclosing catch node, else the enclosing finally block, else EXIT. Bare property reads are
+ *    NOT treated as throwing (documented unsoundness for TypeError-on-undefined).
+ *  - try/catch/finally: region splicing, not duplication — try-body throwers edge to the catch
+ *    node (which binds the exception variable), catch-body throwers to the finally entry or
+ *    outward; a finally block's exits additionally edge to the outer handler (`exception`),
+ *    over-approximating the rethrow continuation.
+ *  - `await` / `yield`: the suspending statement's outgoing normal edge is kind `await_resume` /
+ *    `yield` (resumption), per the shared vocabulary.
+ *  - Short-circuit (`&&`/`||`/`??`), ternaries, and optional chaining stay intra-statement: they
+ *    do not split nodes; their reads are attributed to the containing statement
+ *    (over-approximation, recorded in SCHEMA_DECISIONS.md).
+ *  - Infinite loops (`while (true)` / `for (;;)`): the dead loop-exit `false` edge is still
+ *    emitted from the loop header, which is exactly the synthetic edge post-dominance needs.
+ *  - Nested callables (arrows, function expressions, declarations): the declaring statement is a
+ *    single node in the enclosing CFG; the nested body gets its own CFG (closure capture is a
+ *    def-use concern, stage 3).
+ */
+import { Node, SyntaxKind, type SourceFile } from "ts-morph";
+import type { CfgEdge, CfgEdgeKind } from "../schema";
+import type { DfNode, FunctionCfgBuild } from "./model";
+
+/** A dangling forward edge: source node emitted, target not yet known. */
+interface Dangling {
+  from: number;
+  kind: CfgEdgeKind;
+}
+
+/** Result of lowering a statement (list): its entry node and the dangling normal exits. */
+interface Lowered {
+  entry: number | null; // null ⇒ the region is empty (control passes straight through)
+  exits: Dangling[];
+}
+
+interface LoopLabel {
+  breaks: Dangling[];
+  continueHeader: number | null;
+}
+
+interface LowerCtx {
+  /** Nearest enclosing handler node (catch node / finally entry) or EXIT. */
+  exceptionTarget: number;
+  /** Break/continue sinks of the nearest enclosing loop/switch. */
+  nearestBreaks: Dangling[] | null;
+  nearestContinueHeader: number | null;
+  labels: Map<string, LoopLabel>;
+}
+
+export function buildCfg(signature: string, fn: Node): FunctionCfgBuild | null {
+  const body = getBodyNode(fn);
+  if (!body) return null; // ambient / abstract / overload signature / implicit ctor — no graph
+  const sf = fn.getSourceFile();
+
+  // ---- pass 1: collect the node universe and assign span-ordered ids ----
+  const astNodes: Node[] = [];
+  const params = getParameters(fn);
+  for (const p of params) astNodes.push(p);
+  collectStatementNodes(body, astNodes);
+  astNodes.sort((a, b) => a.getStart() - b.getStart() || b.getEnd() - a.getEnd());
+
+  const nodes: DfNode[] = [{ id: 0, kind: "entry", ast: null }];
+  const idOf = new Map<Node, number>();
+  for (const [i, n] of astNodes.entries()) {
+    const id = i + 1;
+    idOf.set(n, id);
+    nodes.push({ id, kind: Node.isParameterDeclaration(n) ? "param" : "statement", ast: n });
+  }
+  const exitId = astNodes.length + 1;
+  nodes.push({ id: exitId, kind: "exit", ast: null });
+
+  // ---- pass 2: lower to edges ----
+  const edgeSet = new Set<string>();
+  const edges: CfgEdge[] = [];
+  const addEdge = (source: number, target: number, kind: CfgEdgeKind): void => {
+    const k = `${source}>${target}>${kind}`;
+    if (edgeSet.has(k)) return;
+    edgeSet.add(k);
+    edges.push({ source, target, kind });
+  };
+
+  const lower = new Lowerer(idOf, addEdge, exitId);
+  const ctx: LowerCtx = {
+    exceptionTarget: exitId,
+    nearestBreaks: null,
+    nearestContinueHeader: null,
+    labels: new Map(),
+  };
+
+  // ENTRY → params (in order) → body.
+  let cursor: Dangling[] = [{ from: 0, kind: "fallthrough" }];
+  const paramIds: number[] = [];
+  for (const p of params) {
+    const pid = idOf.get(p) as number;
+    paramIds.push(pid);
+    for (const d of cursor) addEdge(d.from, pid, d.kind);
+    cursor = [{ from: pid, kind: "fallthrough" }];
+  }
+
+  let bodyLowered: Lowered;
+  if (Node.isBlock(body)) {
+    bodyLowered = lower.statements(body.getStatements(), ctx);
+  } else {
+    // Arrow expression body: one statement node, implicit return.
+    const id = idOf.get(body) as number;
+    lower.exceptionEdgeIfThrows(body, id, ctx);
+    addEdge(id, exitId, "return");
+    bodyLowered = { entry: id, exits: [] };
+  }
+
+  if (bodyLowered.entry !== null) {
+    for (const d of cursor) addEdge(d.from, bodyLowered.entry, d.kind);
+    cursor = bodyLowered.exits;
+  }
+  // Fall-off-end → EXIT.
+  for (const d of cursor) addEdge(d.from, exitId, d.kind);
+
+  return { signature, fn, sf, nodes, edges, entryId: 0, exitId, paramIds };
+}
+
+// ------------------------------------------------------------------------------------------------
+// Node collection (pass 1)
+// ------------------------------------------------------------------------------------------------
+
+/** Statements (and catch clauses) that become CFG nodes, recursing only through control structure. */
+function collectStatementNodes(node: Node, out: Node[]): void {
+  const stmts = Node.isBlock(node) ? node.getStatements() : [node];
+  for (const s of stmts) {
+    if (Node.isBlock(s)) {
+      collectStatementNodes(s, out);
+    } else if (Node.isLabeledStatement(s)) {
+      collectStatementNodes(s.getStatement(), out);
+    } else if (Node.isIfStatement(s)) {
+      out.push(s);
+      collectStatementNodes(s.getThenStatement(), out);
+      const els = s.getElseStatement();
+      if (els) collectStatementNodes(els, out);
+    } else if (
+      Node.isWhileStatement(s) ||
+      Node.isDoStatement(s) ||
+      Node.isForStatement(s) ||
+      Node.isForOfStatement(s) ||
+      Node.isForInStatement(s)
+    ) {
+      out.push(s);
+      collectStatementNodes(s.getStatement(), out);
+    } else if (Node.isSwitchStatement(s)) {
+      out.push(s);
+      for (const clause of s.getClauses()) for (const cs of clause.getStatements()) collectStatementNodes(cs, out);
+    } else if (Node.isTryStatement(s)) {
+      collectStatementNodes(s.getTryBlock(), out);
+      const cc = s.getCatchClause();
+      if (cc) {
+        out.push(cc);
+        collectStatementNodes(cc.getBlock(), out);
+      }
+      const fin = s.getFinallyBlock();
+      if (fin) collectStatementNodes(fin, out);
+    } else {
+      // Leaf statement: expression / variable / return / throw / break / continue / nested
+      // function or class declaration / debugger / empty. One node; nested bodies excluded.
+      out.push(s);
+    }
+  }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Lowering (pass 2)
+// ------------------------------------------------------------------------------------------------
+
+class Lowerer {
+  constructor(
+    private idOf: Map<Node, number>,
+    private addEdge: (s: number, t: number, k: CfgEdgeKind) => void,
+    private exitId: number,
+  ) {}
+
+  statements(stmts: readonly Node[], ctx: LowerCtx): Lowered {
+    let entry: number | null = null;
+    let cursor: Dangling[] | null = null; // null before the first statement
+    for (const s of stmts) {
+      const low = this.statement(s, ctx);
+      if (low.entry === null) continue; // empty region (e.g. bare block with nothing in it)
+      if (entry === null) entry = low.entry;
+      if (cursor) for (const d of cursor) this.addEdge(d.from, low.entry, d.kind);
+      cursor = low.exits;
+    }
+    return { entry, exits: cursor ?? [] };
+  }
+
+  statement(s: Node, ctx: LowerCtx, label?: string): Lowered {
+    if (Node.isBlock(s)) return this.statements(s.getStatements(), ctx);
+    if (Node.isLabeledStatement(s)) return this.statement(s.getStatement(), ctx, s.getLabel().getText());
+    if (Node.isIfStatement(s)) return this.ifStatement(s, ctx);
+    if (Node.isWhileStatement(s) || Node.isForStatement(s) || Node.isForOfStatement(s) || Node.isForInStatement(s))
+      return this.loop(s, ctx, label);
+    if (Node.isDoStatement(s)) return this.doLoop(s, ctx, label);
+    if (Node.isSwitchStatement(s)) return this.switchStatement(s, ctx);
+    if (Node.isTryStatement(s)) return this.tryStatement(s, ctx);
+    return this.leaf(s, ctx);
+  }
+
+  private leaf(s: Node, ctx: LowerCtx): Lowered {
+    const id = this.idOf.get(s) as number;
+    this.exceptionEdgeIfThrows(s, id, ctx);
+
+    if (Node.isReturnStatement(s)) {
+      this.addEdge(id, this.exitId, "return");
+      return { entry: id, exits: [] };
+    }
+    if (Node.isThrowStatement(s)) {
+      this.addEdge(id, ctx.exceptionTarget, "exception");
+      return { entry: id, exits: [] };
+    }
+    if (Node.isBreakStatement(s)) {
+      const lbl = s.getLabel()?.getText();
+      const sink = lbl ? ctx.labels.get(lbl)?.breaks : ctx.nearestBreaks;
+      sink?.push({ from: id, kind: "break" });
+      return { entry: id, exits: [] };
+    }
+    if (Node.isContinueStatement(s)) {
+      const lbl = s.getLabel()?.getText();
+      const header = lbl ? (ctx.labels.get(lbl)?.continueHeader ?? null) : ctx.nearestContinueHeader;
+      if (header !== null) this.addEdge(id, header, "continue");
+      return { entry: id, exits: [] };
+    }
+    // Plain statement: the outgoing normal edge carries the suspend/resume kind when the
+    // statement awaits or yields (stopping at nested function boundaries).
+    const kind: CfgEdgeKind = containsKind(s, SyntaxKind.AwaitExpression)
+      ? "await_resume"
+      : containsKind(s, SyntaxKind.YieldExpression)
+        ? "yield"
+        : "fallthrough";
+    return { entry: id, exits: [{ from: id, kind }] };
+  }
+
+  private ifStatement(s: Node, ctx: LowerCtx): Lowered {
+    if (!Node.isIfStatement(s)) throw new Error("unreachable");
+    const id = this.idOf.get(s) as number;
+    this.exceptionEdgeIfThrows(s.getExpression(), id, ctx);
+    const then = this.statement(s.getThenStatement(), ctx);
+    const exits: Dangling[] = [];
+    if (then.entry !== null) {
+      this.addEdge(id, then.entry, "true");
+      exits.push(...then.exits);
+    } else {
+      exits.push({ from: id, kind: "true" });
+    }
+    const elseStmt = s.getElseStatement();
+    if (elseStmt) {
+      const els = this.statement(elseStmt, ctx);
+      if (els.entry !== null) {
+        this.addEdge(id, els.entry, "false");
+        exits.push(...els.exits);
+      } else {
+        exits.push({ from: id, kind: "false" });
+      }
+    } else {
+      exits.push({ from: id, kind: "false" });
+    }
+    return { entry: id, exits };
+  }
+
+  /** while / for / for-of / for-in: the statement node is the header (condition/binding). */
+  private loop(s: Node, ctx: LowerCtx, label?: string): Lowered {
+    const id = this.idOf.get(s) as number;
+    const cond = Node.isWhileStatement(s)
+      ? s.getExpression()
+      : Node.isForStatement(s)
+        ? (s.getCondition() ?? null)
+        : Node.isForOfStatement(s) || Node.isForInStatement(s)
+          ? s.getExpression()
+          : null;
+    if (Node.isForStatement(s)) {
+      const init = s.getInitializer();
+      if (init) this.exceptionEdgeIfThrows(init, id, ctx);
+      const incr = s.getIncrementor();
+      if (incr) this.exceptionEdgeIfThrows(incr, id, ctx);
+    }
+    if (cond) this.exceptionEdgeIfThrows(cond, id, ctx);
+
+    const breaks: Dangling[] = [];
+    const labelEntry: LoopLabel = { breaks, continueHeader: id };
+    if (label) ctx.labels.set(label, labelEntry);
+    const bodyCtx: LowerCtx = { ...ctx, nearestBreaks: breaks, nearestContinueHeader: id };
+    const body = this.statement(getLoopBody(s), bodyCtx);
+    if (label) ctx.labels.delete(label);
+
+    if (body.entry !== null) {
+      this.addEdge(id, body.entry, "true");
+      for (const d of body.exits) this.addEdge(d.from, id, "loop_back");
+    } else {
+      this.addEdge(id, id, "loop_back"); // empty body: the header loops on itself
+    }
+    // The loop-exit edge is emitted even for `while (true)` / `for (;;)` — that dead `false`
+    // edge is the synthetic edge that keeps EXIT the unique post-dominance root.
+    return { entry: id, exits: [{ from: id, kind: "false" }, ...breaks] };
+  }
+
+  private doLoop(s: Node, ctx: LowerCtx, label?: string): Lowered {
+    if (!Node.isDoStatement(s)) throw new Error("unreachable");
+    const id = this.idOf.get(s) as number; // the do-while node carries the condition
+    this.exceptionEdgeIfThrows(s.getExpression(), id, ctx);
+    const breaks: Dangling[] = [];
+    if (label) ctx.labels.set(label, { breaks, continueHeader: id });
+    const bodyCtx: LowerCtx = { ...ctx, nearestBreaks: breaks, nearestContinueHeader: id };
+    const body = this.statement(s.getStatement(), bodyCtx);
+    if (label) ctx.labels.delete(label);
+
+    if (body.entry !== null) {
+      for (const d of body.exits) this.addEdge(d.from, id, d.kind);
+      this.addEdge(id, body.entry, "loop_back"); // condition true → run the body again
+      return { entry: body.entry, exits: [{ from: id, kind: "false" }, ...breaks] };
+    }
+    this.addEdge(id, id, "loop_back");
+    return { entry: id, exits: [{ from: id, kind: "false" }, ...breaks] };
+  }
+
+  private switchStatement(s: Node, ctx: LowerCtx): Lowered {
+    if (!Node.isSwitchStatement(s)) throw new Error("unreachable");
+    const id = this.idOf.get(s) as number;
+    this.exceptionEdgeIfThrows(s.getExpression(), id, ctx);
+    const breaks: Dangling[] = [];
+    const clauseCtx: LowerCtx = { ...ctx, nearestBreaks: breaks };
+
+    const clauses = s.getClauses();
+    const lowered = clauses.map((c) => this.statements(c.getStatements(), clauseCtx));
+    const exits: Dangling[] = [];
+    let nonEmptyDefault = false;
+    let pendingFallthrough: Dangling[] = [];
+    for (const [i, clause] of clauses.entries()) {
+      const low = lowered[i] as Lowered;
+      if (low.entry === null) continue; // empty clause: dispatch/fallthrough slides to the next
+      if (Node.isDefaultClause(clause)) nonEmptyDefault = true;
+      this.addEdge(id, low.entry, "switch_case");
+      for (const d of pendingFallthrough) this.addEdge(d.from, low.entry, d.kind);
+      pendingFallthrough = low.exits;
+    }
+    exits.push(...pendingFallthrough, ...breaks);
+    // Without a (non-empty) default arm, dispatch may skip the switch entirely.
+    if (!nonEmptyDefault) exits.push({ from: id, kind: "fallthrough" });
+    return { entry: id, exits };
+  }
+
+  private tryStatement(s: Node, ctx: LowerCtx): Lowered {
+    if (!Node.isTryStatement(s)) throw new Error("unreachable");
+    const cc = s.getCatchClause();
+    const fin = s.getFinallyBlock();
+
+    // Lower the finally region first so try/catch know their exceptional continuation.
+    let finLowered: Lowered | null = null;
+    if (fin) {
+      finLowered = this.statements(fin.getStatements(), ctx);
+      // A finally region may re-raise (it runs on the exceptional path too): over-approximate by
+      // edging every finally exit to the outer handler as well.
+      if (finLowered.entry !== null) {
+        for (const d of finLowered.exits) this.addEdge(d.from, ctx.exceptionTarget, "exception");
+      }
+    }
+    const afterCatchTarget = finLowered?.entry ?? ctx.exceptionTarget;
+
+    const exits: Dangling[] = [];
+    let catchEntry: number | null = null;
+    if (cc) {
+      const catchId = this.idOf.get(cc) as number; // binds the exception variable (a def, stage 3)
+      catchEntry = catchId;
+      const catchCtx: LowerCtx = { ...ctx, exceptionTarget: afterCatchTarget };
+      const catchBody = this.statements(cc.getBlock().getStatements(), catchCtx);
+      if (catchBody.entry !== null) {
+        this.addEdge(catchId, catchBody.entry, "fallthrough");
+        this.routeThroughFinally(catchBody.exits, finLowered, exits);
+      } else {
+        this.routeThroughFinally([{ from: catchId, kind: "fallthrough" }], finLowered, exits);
+      }
+    }
+
+    const tryCtx: LowerCtx = { ...ctx, exceptionTarget: catchEntry ?? afterCatchTarget };
+    const tryBody = this.statements(s.getTryBlock().getStatements(), tryCtx);
+    if (tryBody.entry !== null) this.routeThroughFinally(tryBody.exits, finLowered, exits);
+    else if (finLowered?.entry != null) this.routeThroughFinally([], finLowered, exits);
+
+    const entry = tryBody.entry ?? catchEntry ?? finLowered?.entry ?? null;
+    if (tryBody.entry === null && finLowered?.entry !== null && finLowered) {
+      // Empty try block: control passes straight to finally.
+      exits.push(...finLowered.exits);
+    }
+    return { entry, exits };
+  }
+
+  /** Route a region's normal exits through the finally block (if any) or straight out. */
+  private routeThroughFinally(regionExits: Dangling[], fin: Lowered | null, outExits: Dangling[]): void {
+    if (fin && fin.entry !== null) {
+      for (const d of regionExits) this.addEdge(d.from, fin.entry, d.kind);
+      for (const d of fin.exits) if (!outExits.includes(d)) outExits.push(d);
+    } else {
+      outExits.push(...regionExits);
+    }
+  }
+
+  /** Over-approximate exceptional flow: calls / new / await / tagged templates may throw. */
+  exceptionEdgeIfThrows(expr: Node, nodeId: number, ctx: LowerCtx): void {
+    if (mayThrow(expr)) this.addEdge(nodeId, ctx.exceptionTarget, "exception");
+  }
+}
+
+// ------------------------------------------------------------------------------------------------
+// AST helpers
+// ------------------------------------------------------------------------------------------------
+
+function getBodyNode(fn: Node): Node | undefined {
+  const f = fn as unknown as { getBody?: () => Node | undefined };
+  return f.getBody?.();
+}
+
+function getParameters(fn: Node): Node[] {
+  const f = fn as unknown as { getParameters?: () => Node[] };
+  return f.getParameters?.() ?? [];
+}
+
+function getLoopBody(s: Node): Node {
+  return (s as unknown as { getStatement: () => Node }).getStatement();
+}
+
+export function isFunctionBoundary(n: Node): boolean {
+  return (
+    Node.isFunctionDeclaration(n) ||
+    Node.isFunctionExpression(n) ||
+    Node.isArrowFunction(n) ||
+    Node.isMethodDeclaration(n) ||
+    Node.isConstructorDeclaration(n) ||
+    Node.isGetAccessorDeclaration(n) ||
+    Node.isSetAccessorDeclaration(n) ||
+    Node.isClassDeclaration(n) ||
+    Node.isClassExpression(n)
+  );
+}
+
+/** Does this subtree (stopping at nested function boundaries) contain a node of `kind`? */
+export function containsKind(root: Node, kind: SyntaxKind): boolean {
+  if (root.getKind() === kind) return true;
+  let found = false;
+  root.forEachDescendant((n, traversal) => {
+    if (found) {
+      traversal.stop();
+      return;
+    }
+    if (isFunctionBoundary(n)) {
+      traversal.skip();
+      return;
+    }
+    if (n.getKind() === kind) {
+      found = true;
+      traversal.stop();
+    }
+  });
+  return found;
+}
+
+/** May evaluating this subtree throw? Over-approximate: any call-like or await counts. */
+export function mayThrow(root: Node): boolean {
+  return (
+    containsKind(root, SyntaxKind.CallExpression) ||
+    containsKind(root, SyntaxKind.NewExpression) ||
+    containsKind(root, SyntaxKind.AwaitExpression) ||
+    containsKind(root, SyntaxKind.TaggedTemplateExpression)
+  );
+}
diff --git a/src/dataflow/defuse.ts b/src/dataflow/defuse.ts
new file mode 100644
index 0000000..2b1bd6e
--- /dev/null
+++ b/src/dataflow/defuse.ts
@@ -0,0 +1,631 @@
+/**
+ * Stage 3 — variable identity (k-limited access paths) and local def-use (the DDG).
+ *
+ * Access-path model: `base(.field | [*])*`, where the base is a local, parameter, `this`,
+ * captured variable, or module binding — identified by its *declaration node* (so shadowed names
+ * in nested scopes never share a base) and labeled by its name. Module bindings are canonical
+ * `<modulePrefix>.<name>` (the same prefix as signatures), which is what lets globals ride the
+ * SDG across functions and files. Depth is k-limited (`--graph-field-depth`): `x.f.g.h` with k=3
+ * becomes `x.f.g.*`, which conservatively aliases every deeper path.
+ *
+ * Aliasing (MVP substrate, per issue #2 / SCHEMA_DECISIONS.md): flow-insensitive union-find over
+ * bases connected by direct copies (`const q = p`); a write through one name weakly updates the
+ * other. Points-to-backed aliasing via Jelly's solved state is the staged upgrade (PR F).
+ *
+ * Def-use: classic forward may reaching-definitions over the stage-1 CFG. Strong (killing)
+ * defs are whole-base writes to locals/params; every field write is weak. Captured/module/this
+ * bases get a synthetic def at ENTRY (their value on function entry) — the same convention the
+ * SDG uses when it targets ENTRY with global PARAM_IN edges. Reads inside nested callables of
+ * variables they capture are attributed to the declaring statement node (capture-at-declaration).
+ *
+ * Call-site global effects (`callEffects`): the summary driver (stage 6) re-runs this analysis
+ * with the transitive global reads/writes of each call's callee applied at the callsite node,
+ * which is how cross-function global flow becomes visible in the caller's DDG.
+ */
+import { Node, SyntaxKind } from "ts-morph";
+import type { PdgEdge } from "../schema";
+import { fileKeyOf } from "../schema";
+import { isFunctionBoundary } from "./cfg";
+import { adjacency, type DfNode, type FunctionCfgBuild } from "./model";
+
+// ------------------------------------------------------------------------------------------------
+// Access paths
+// ------------------------------------------------------------------------------------------------
+
+export type BaseKind = "local" | "param" | "this" | "captured" | "module";
+
+export interface PathRef {
+  /** Unique base identity: decl-position for locals/params/captured, canonical path for module, "this". */
+  key: string;
+  /** Human label for the base (the variable name / canonical module path). */
+  label: string;
+  baseKind: BaseKind;
+  fields: string[]; // "f" | "[*]" | "*" (trailing truncation star)
+}
+
+export function renderPath(p: PathRef): string {
+  let s = p.label;
+  for (const f of p.fields) s += f === "[*]" ? "[*]" : `.${f}`;
+  return s;
+}
+
+/** A global (module-binding) path as carried by summaries: canonical base + fields. */
+export interface GlobalPath {
+  key: string; // == the canonical `<modulePrefix>.<name>` label
+  fields: string[];
+}
+
+export function renderGlobal(g: GlobalPath): string {
+  return renderPath({ key: g.key, label: g.key, baseKind: "module", fields: g.fields });
+}
+
+function kLimit(fields: string[], k: number): string[] {
+  return fields.length > k ? [...fields.slice(0, k), "*"] : fields;
+}
+
+/** May two field lists overlap? "*" (truncation) matches any tail; "[*]" matches any one step. */
+function fieldsMayAlias(a: string[], b: string[]): boolean {
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) {
+    const x = a[i] as string;
+    const y = b[i] as string;
+    if (x === "*" || y === "*") return true;
+    if (x === "[*]" || y === "[*]") continue; // dynamic index may hit any member
+    if (x !== y) return false;
+  }
+  return true; // one path is a prefix of the other (whole-object vs member)
+}
+
+// ------------------------------------------------------------------------------------------------
+// Per-node dataflow facts
+// ------------------------------------------------------------------------------------------------
+
+export interface DefFact {
+  ref: PathRef;
+  /** Strong defs kill; only whole-base writes of locals/params qualify (field writes are weak). */
+  strong: boolean;
+}
+
+export interface NodeFacts {
+  defs: DefFact[];
+  uses: PathRef[];
+}
+
+export interface CallEffects {
+  reads: GlobalPath[];
+  writes: GlobalPath[];
+}
+
+export interface DefUseResult {
+  ddg: PdgEdge[];
+  facts: Map<number, NodeFacts>;
+  /** Union-find representative per base key (the copy-alias classes). */
+  aliasRep: Map<string, string>;
+  /** Nodes that produce the function's return value (`return expr` / arrow expression body). */
+  returnValueNodes: Set<number>;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Base resolution
+// ------------------------------------------------------------------------------------------------
+
+function enclosingCallable(node: Node): Node | undefined {
+  let cur: Node | undefined = node.getParent();
+  while (cur) {
+    if (
+      Node.isFunctionDeclaration(cur) ||
+      Node.isFunctionExpression(cur) ||
+      Node.isArrowFunction(cur) ||
+      Node.isMethodDeclaration(cur) ||
+      Node.isConstructorDeclaration(cur) ||
+      Node.isGetAccessorDeclaration(cur) ||
+      Node.isSetAccessorDeclaration(cur)
+    )
+      return cur;
+    cur = cur.getParent();
+  }
+  return undefined;
+}
+
+/** Resolve an identifier (in value position) to a trackable base, relative to callable `fn`. */
+function resolveBase(id: Node, fn: Node, root: string): PathRef | null {
+  let sym = id.getSymbol();
+  if (!sym) return null;
+  const aliased = sym.getAliasedSymbol();
+  if (aliased) sym = aliased;
+  const decls = sym.getDeclarations();
+  const decl = decls && decls.length ? decls[0] : undefined;
+  if (!decl) return null;
+
+  // Only variable-like declarations are dataflow bases. Callables, classes, enums, interfaces,
+  // namespaces and type aliases are code/type identities, not mutable values we track.
+  const isVarLike =
+    Node.isVariableDeclaration(decl) || Node.isBindingElement(decl) || Node.isParameterDeclaration(decl);
+  if (!isVarLike) return null;
+
+  const name = (decl as unknown as { getName?: () => string }).getName?.() ?? id.getText();
+  const declFn = enclosingCallable(decl);
+  if (declFn === fn) {
+    const kind: BaseKind = Node.isParameterDeclaration(decl) ? "param" : "local";
+    return { key: `${kind}:${decl.getStart()}`, label: name, baseKind: kind, fields: [] };
+  }
+  if (declFn === undefined) {
+    // Module-level binding. Only project-internal modules become canonical global paths.
+    const sf = decl.getSourceFile();
+    const fp = sf.getFilePath();
+    if (sf.isDeclarationFile() || fp.includes("/node_modules/")) return null;
+    const { modulePrefix } = fileKeyOf(fp, root);
+    const canonical = `${modulePrefix}.${name}`;
+    return { key: canonical, label: canonical, baseKind: "module", fields: [] };
+  }
+  // Declared in some other (enclosing) callable: captured.
+  return { key: `cap:${decl.getStart()}`, label: name, baseKind: "captured", fields: [] };
+}
+
+// ------------------------------------------------------------------------------------------------
+// Expression walking (defs/uses extraction)
+// ------------------------------------------------------------------------------------------------
+
+class ExprWalker {
+  defs: DefFact[] = [];
+  uses: PathRef[] = [];
+
+  constructor(
+    private fn: Node,
+    private root: string,
+    private k: number,
+    private union: (a: string, b: string) => void,
+  ) {}
+
+  walk(node: Node): void {
+    if (Node.isIdentifier(node)) {
+      const b = resolveBase(node, this.fn, this.root);
+      if (b) this.uses.push(b);
+      return;
+    }
+    if (node.getKind() === SyntaxKind.ThisKeyword) {
+      this.uses.push({ key: "this", label: "this", baseKind: "this", fields: [] });
+      return;
+    }
+    if (Node.isPropertyAccessExpression(node) || Node.isElementAccessExpression(node)) {
+      const p = this.pathOf(node);
+      if (p) this.uses.push(p);
+      else for (const c of node.forEachChildAsArray()) this.walk(c);
+      if (Node.isElementAccessExpression(node)) {
+        const arg = node.getArgumentExpression();
+        if (arg) this.walk(arg); // the index expression is read even when the path resolves
+      }
+      return;
+    }
+    if (Node.isBinaryExpression(node)) {
+      const opKind = node.getOperatorToken().getKind();
+      if (isAssignmentOperator(opKind)) {
+        this.assignTarget(node.getLeft(), opKind !== SyntaxKind.EqualsToken);
+        this.walk(node.getRight());
+        if (opKind === SyntaxKind.EqualsToken) this.copyUnion(node.getLeft(), node.getRight());
+        return;
+      }
+      this.walk(node.getLeft());
+      this.walk(node.getRight());
+      return;
+    }
+    if (Node.isPrefixUnaryExpression(node) || Node.isPostfixUnaryExpression(node)) {
+      const op = node.getOperatorToken();
+      if (op === SyntaxKind.PlusPlusToken || op === SyntaxKind.MinusMinusToken) {
+        this.assignTarget(node.getOperand(), true);
+        return;
+      }
+      this.walk(node.getOperand());
+      return;
+    }
+    if (Node.isVariableDeclaration(node)) {
+      const nameNode = node.getNameNode();
+      this.bindingDefs(nameNode);
+      const init = node.getInitializer();
+      if (init) {
+        this.walk(init);
+        if (Node.isIdentifier(nameNode)) this.copyUnion(nameNode, init);
+      }
+      return;
+    }
+    if (Node.isShorthandPropertyAssignment(node)) {
+      const b = resolveBase(node.getNameNode(), this.fn, this.root);
+      if (b) this.uses.push(b);
+      return;
+    }
+    if (Node.isPropertyAssignment(node)) {
+      const init = node.getInitializer();
+      if (init) this.walk(init);
+      const nm = node.getNameNode();
+      if (Node.isComputedPropertyName(nm)) this.walk(nm);
+      return;
+    }
+    if (isFunctionBoundary(node)) {
+      this.captureScan(node);
+      return;
+    }
+    // Generic recursion. Type-position identifiers resolve to type declarations, which
+    // resolveBase rejects, so descending everywhere else is safe.
+    for (const c of node.forEachChildAsArray()) this.walk(c);
+  }
+
+  /** LHS of an assignment / operand of ++ --: a def (plus a use for compound operators). */
+  assignTarget(lhs: Node, alsoUses: boolean): void {
+    const target = unwrapExpr(lhs);
+    const p = this.pathOf(target) ?? (Node.isIdentifier(target) ? resolveBase(target, this.fn, this.root) : null);
+    if (target.getKind() === SyntaxKind.ThisKeyword) return; // `this` is not assignable
+    if (p) {
+      const strong = p.fields.length === 0 && (p.baseKind === "local" || p.baseKind === "param");
+      this.defs.push({ ref: p, strong });
+      if (alsoUses) this.uses.push(p);
+      if (Node.isElementAccessExpression(target)) {
+        const arg = target.getArgumentExpression();
+        if (arg) this.walk(arg);
+      }
+      return;
+    }
+    if (Node.isObjectLiteralExpression(target) || Node.isArrayLiteralExpression(target)) {
+      // Destructuring assignment pattern: each element identifier is a def.
+      for (const el of target.forEachChildAsArray()) this.assignTarget(el, false);
+      return;
+    }
+    // Untrackable target (e.g. `f().x = 1`): its subexpressions are still reads.
+    this.walk(target);
+  }
+
+  /** Declaration name / binding pattern: strong defs for every bound name. */
+  bindingDefs(nameNode: Node): void {
+    if (Node.isIdentifier(nameNode)) {
+      const b = resolveBase(nameNode, this.fn, this.root);
+      if (b) this.defs.push({ ref: b, strong: b.baseKind === "local" || b.baseKind === "param" });
+      return;
+    }
+    // Object/array binding pattern: defs for each element name, uses for defaults/computed keys.
+    for (const el of nameNode.getDescendantsOfKind(SyntaxKind.BindingElement)) {
+      const n = el.getNameNode();
+      if (Node.isIdentifier(n)) {
+        const b = resolveBase(n, this.fn, this.root);
+        if (b) this.defs.push({ ref: b, strong: b.baseKind === "local" || b.baseKind === "param" });
+      }
+      const init = el.getInitializer();
+      if (init) this.walk(init);
+    }
+  }
+
+  /** Build a k-limited access path from a property/element access chain, if the root is trackable. */
+  private pathOf(node: Node): PathRef | null {
+    const fields: string[] = [];
+    let cur: Node = node;
+    for (;;) {
+      cur = unwrapExpr(cur);
+      if (Node.isPropertyAccessExpression(cur)) {
+        fields.unshift(cur.getNameNode().getText());
+        cur = cur.getExpression();
+      } else if (Node.isElementAccessExpression(cur)) {
+        fields.unshift("[*]");
+        cur = cur.getExpression();
+      } else {
+        break;
+      }
+    }
+    let base: PathRef | null = null;
+    if (Node.isIdentifier(cur)) base = resolveBase(cur, this.fn, this.root);
+    else if (cur.getKind() === SyntaxKind.ThisKeyword) base = { key: "this", label: "this", baseKind: "this", fields: [] };
+    if (!base) return null;
+    return { ...base, fields: kLimit(fields, this.k) };
+  }
+
+  /** `q = p` on bare bases: q and p may alias from here on (flow-insensitive, weak). */
+  private copyUnion(lhs: Node, rhs: Node): void {
+    const l = unwrapExpr(lhs);
+    const r = unwrapExpr(rhs);
+    if (!Node.isIdentifier(l) || !Node.isIdentifier(r)) return;
+    const lb = resolveBase(l, this.fn, this.root);
+    const rb = resolveBase(r, this.fn, this.root);
+    if (lb && rb) this.union(lb.key, rb.key);
+  }
+
+  /**
+   * A nested callable: don't descend normally — attribute its reads of variables declared
+   * OUTSIDE it (captured locals, module bindings, `this`) to the declaring node (capture edges).
+   */
+  captureScan(fnNode: Node): void {
+    fnNode.forEachDescendant((n) => {
+      if (Node.isIdentifier(n)) {
+        // Skip property-name positions; the receiver carries the read.
+        const parent = n.getParent();
+        if (parent && Node.isPropertyAccessExpression(parent) && parent.getNameNode() === n) return;
+        if (parent && Node.isPropertyAssignment(parent) && parent.getNameNode() === n) return;
+        const b = resolveBase(n, this.fn, this.root);
+        if (!b) return;
+        // Only reads that escape the nested callable count: a decl inside it resolves to
+        // local/param of the *outer* fn only when it isn't nested — resolveBase already keys by
+        // decl site, so filter decls physically inside the nested subtree.
+        const decl = declOf(n);
+        if (decl && decl.getStart() >= fnNode.getStart() && decl.getEnd() <= fnNode.getEnd()) return;
+        this.uses.push(b);
+      } else if (n.getKind() === SyntaxKind.ThisKeyword) {
+        this.uses.push({ key: "this", label: "this", baseKind: "this", fields: [] });
+      }
+    });
+  }
+}
+
+function declOf(id: Node): Node | undefined {
+  let sym = id.getSymbol();
+  if (!sym) return undefined;
+  const aliased = sym.getAliasedSymbol();
+  if (aliased) sym = aliased;
+  const decls = sym.getDeclarations();
+  return decls && decls.length ? decls[0] : undefined;
+}
+
+function unwrapExpr(n: Node): Node {
+  let cur = n;
+  for (;;) {
+    if (
+      Node.isParenthesizedExpression(cur) ||
+      Node.isAsExpression(cur) ||
+      Node.isNonNullExpression(cur) ||
+      Node.isSatisfiesExpression(cur)
+    ) {
+      cur = cur.getExpression();
+    } else {
+      return cur;
+    }
+  }
+}
+
+function isAssignmentOperator(k: SyntaxKind): boolean {
+  return k >= SyntaxKind.FirstAssignment && k <= SyntaxKind.LastAssignment;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Per-node fact extraction
+// ------------------------------------------------------------------------------------------------
+
+function extractFacts(
+  n: DfNode,
+  build: FunctionCfgBuild,
+  root: string,
+  k: number,
+  union: (a: string, b: string) => void,
+): NodeFacts {
+  const w = new ExprWalker(build.fn, root, k, union);
+  const ast = n.ast;
+  if (!ast) return { defs: [], uses: [] };
+
+  if (n.kind === "param") {
+    if (Node.isParameterDeclaration(ast)) {
+      w.bindingDefs(ast.getNameNode());
+      const init = ast.getInitializer();
+      if (init) w.walk(init);
+    }
+    return { defs: w.defs, uses: w.uses };
+  }
+
+  if (Node.isCatchClause(ast)) {
+    const v = ast.getVariableDeclaration();
+    if (v) w.bindingDefs(v.getNameNode());
+    return { defs: w.defs, uses: w.uses };
+  }
+  if (Node.isIfStatement(ast) || Node.isWhileStatement(ast) || Node.isDoStatement(ast) || Node.isSwitchStatement(ast)) {
+    w.walk(ast.getExpression());
+    return { defs: w.defs, uses: w.uses };
+  }
+  if (Node.isForStatement(ast)) {
+    const init = ast.getInitializer();
+    if (init) w.walk(init);
+    const cond = ast.getCondition();
+    if (cond) w.walk(cond);
+    const incr = ast.getIncrementor();
+    if (incr) w.walk(incr);
+    return { defs: w.defs, uses: w.uses };
+  }
+  if (Node.isForOfStatement(ast) || Node.isForInStatement(ast)) {
+    const init = ast.getInitializer();
+    if (init) {
+      if (Node.isVariableDeclarationList(init)) {
+        for (const d of init.getDeclarations()) w.bindingDefs(d.getNameNode());
+      } else {
+        w.assignTarget(init, false);
+      }
+    }
+    w.walk(ast.getExpression());
+    return { defs: w.defs, uses: w.uses };
+  }
+  if (Node.isReturnStatement(ast) || Node.isThrowStatement(ast)) {
+    const e = (ast as unknown as { getExpression: () => Node | undefined }).getExpression();
+    if (e) w.walk(e);
+    return { defs: w.defs, uses: w.uses };
+  }
+  if (Node.isFunctionDeclaration(ast) || Node.isClassDeclaration(ast)) {
+    // Nested declaration statement: binds its name; body reads of outer state are capture uses.
+    const nm = (ast as unknown as { getNameNode?: () => Node | undefined }).getNameNode?.();
+    if (nm && Node.isIdentifier(nm)) {
+      const b = resolveBase(nm, build.fn, root);
+      if (b) w.defs.push({ ref: b, strong: true });
+    }
+    w.captureScan(ast);
+    return { defs: w.defs, uses: w.uses };
+  }
+  if (Node.isBreakStatement(ast) || Node.isContinueStatement(ast) || Node.isDebuggerStatement(ast)) {
+    return { defs: [], uses: [] };
+  }
+  // Expression statement, variable statement, arrow expression body, or any other leaf.
+  w.walk(ast);
+  return { defs: w.defs, uses: w.uses };
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reaching definitions → DDG
+// ------------------------------------------------------------------------------------------------
+
+export function computeDefUse(
+  build: FunctionCfgBuild,
+  root: string,
+  k: number,
+  callEffects: Map<number, CallEffects>,
+): DefUseResult {
+  // --- union-find over base keys (copy aliases) ---
+  const parent = new Map<string, string>();
+  const find = (x: string): string => {
+    let r = x;
+    while (parent.has(r) && parent.get(r) !== r) r = parent.get(r) as string;
+    return r;
+  };
+  const union = (a: string, b: string): void => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent.set(ra, rb);
+  };
+
+  // --- facts per node ---
+  const facts = new Map<number, NodeFacts>();
+  for (const n of build.nodes) {
+    if (n.kind === "entry" || n.kind === "exit") {
+      facts.set(n.id, { defs: [], uses: [] });
+      continue;
+    }
+    facts.set(n.id, extractFacts(n, build, root, k, union));
+  }
+
+  // --- apply callee global effects at callsite nodes ---
+  for (const [nodeId, eff] of callEffects) {
+    const f = facts.get(nodeId);
+    if (!f) continue;
+    for (const g of eff.reads) f.uses.push({ key: g.key, label: g.key, baseKind: "module", fields: g.fields });
+    for (const g of eff.writes)
+      f.defs.push({ ref: { key: g.key, label: g.key, baseKind: "module", fields: g.fields }, strong: false });
+  }
+
+  // --- ENTRY defs for ambient bases (module / captured / this): their value on entry ---
+  const entryFacts = facts.get(build.entryId) as NodeFacts;
+  const ambient = new Map<string, PathRef>();
+  for (const f of facts.values()) {
+    for (const u of f.uses) if (u.baseKind !== "local" && u.baseKind !== "param") ambient.set(u.key, u);
+    for (const d of f.defs) if (d.ref.baseKind !== "local" && d.ref.baseKind !== "param") ambient.set(d.ref.key, d.ref);
+  }
+  for (const [key, ref] of ambient) {
+    entryFacts.defs.push({ ref: { key, label: ref.label, baseKind: ref.baseKind, fields: [] }, strong: false });
+  }
+
+  // --- def universe + GEN/KILL ---
+  interface DefEntry {
+    node: number;
+    ref: PathRef;
+    strong: boolean;
+  }
+  const universe: DefEntry[] = [];
+  const genOf = new Map<number, Set<number>>();
+  for (const n of build.nodes) {
+    const gen = new Set<number>();
+    for (const d of facts.get(n.id)?.defs ?? []) {
+      gen.add(universe.length);
+      universe.push({ node: n.id, ref: d.ref, strong: d.strong });
+    }
+    genOf.set(n.id, gen);
+  }
+  const killOf = new Map<number, Set<number>>();
+  for (const n of build.nodes) {
+    const kill = new Set<number>();
+    for (const d of facts.get(n.id)?.defs ?? []) {
+      if (!d.strong) continue;
+      for (const [i, u] of universe.entries()) {
+        if (u.node !== n.id && find(u.ref.key) === find(d.ref.key)) kill.add(i);
+      }
+    }
+    killOf.set(n.id, kill);
+  }
+
+  // --- worklist ---
+  const { succ, pred } = adjacency(build);
+  const inOf = new Map<number, Set<number>>();
+  const outOf = new Map<number, Set<number>>();
+  for (const n of build.nodes) {
+    inOf.set(n.id, new Set());
+    outOf.set(n.id, new Set());
+  }
+  const work: number[] = build.nodes.map((n) => n.id);
+  while (work.length) {
+    const id = work.shift() as number;
+    const inSet = new Set<number>();
+    for (const p of pred.get(id) ?? []) for (const d of outOf.get(p) ?? []) inSet.add(d);
+    const outSet = new Set<number>(genOf.get(id));
+    const kill = killOf.get(id) as Set<number>;
+    for (const d of inSet) if (!kill.has(d)) outSet.add(d);
+    inOf.set(id, inSet);
+    const prev = outOf.get(id) as Set<number>;
+    if (outSet.size !== prev.size || [...outSet].some((d) => !prev.has(d))) {
+      outOf.set(id, outSet);
+      for (const s of succ.get(id) ?? []) if (!work.includes(s)) work.push(s);
+    }
+  }
+
+  // --- DDG edges: def → use of a may-aliasing path ---
+  const mayAlias = (a: PathRef, b: PathRef): boolean =>
+    find(a.key) === find(b.key) && fieldsMayAlias(a.fields, b.fields);
+  const ddg: PdgEdge[] = [];
+  const seen = new Set<string>();
+  for (const n of build.nodes) {
+    const f = facts.get(n.id) as NodeFacts;
+    if (!f.uses.length) continue;
+    const reaching = inOf.get(n.id) as Set<number>;
+    for (const u of f.uses) {
+      for (const di of reaching) {
+        const d = universe[di] as DefEntry;
+        if (!mayAlias(d.ref, u)) continue;
+        const k2 = `${d.node}>${n.id}>${renderPath(u)}`;
+        if (seen.has(k2)) continue;
+        seen.add(k2);
+        ddg.push({ source: d.node, target: n.id, type: "DDG", var: renderPath(u) });
+      }
+    }
+  }
+
+  // --- return-value nodes ---
+  const returnValueNodes = new Set<number>();
+  const body = getBody(build.fn);
+  const isExprBody = body !== undefined && !Node.isBlock(body);
+  for (const n of build.nodes) {
+    if (!n.ast) continue;
+    if (Node.isReturnStatement(n.ast) && n.ast.getExpression()) returnValueNodes.add(n.id);
+    else if (isExprBody && n.ast === body) returnValueNodes.add(n.id); // arrow expression body
+  }
+
+  // --- formal-out routing: EXIT doubles as the SDG formal-out node ---
+  // PARAM_OUT edges source at the callee's EXIT, so the value that leaves the function must flow
+  // INTO it: return-value nodes carry the return value, module-global writes are live-out state.
+  // Without these edges a slice descending a PARAM_OUT would dead-end at EXIT.
+  for (const r of [...returnValueNodes].sort((a, b) => a - b)) {
+    const k2 = `${r}>${build.exitId}>return`;
+    if (!seen.has(k2)) {
+      seen.add(k2);
+      ddg.push({ source: r, target: build.exitId, type: "DDG", var: "return" });
+    }
+  }
+  for (const n of build.nodes) {
+    if (n.id === build.entryId) continue;
+    for (const d of facts.get(n.id)?.defs ?? []) {
+      if (d.ref.baseKind !== "module") continue;
+      const rendered = renderPath(d.ref);
+      const k2 = `${n.id}>${build.exitId}>${rendered}`;
+      if (!seen.has(k2)) {
+        seen.add(k2);
+        ddg.push({ source: n.id, target: build.exitId, type: "DDG", var: rendered });
+      }
+    }
+  }
+
+  const aliasRep = new Map<string, string>();
+  for (const f of facts.values()) {
+    for (const u of f.uses) aliasRep.set(u.key, find(u.key));
+    for (const d of f.defs) aliasRep.set(d.ref.key, find(d.ref.key));
+  }
+
+  return { ddg, facts, aliasRep, returnValueNodes };
+}
+
+function getBody(fn: Node): Node | undefined {
+  return (fn as unknown as { getBody?: () => Node | undefined }).getBody?.();
+}
diff --git a/src/dataflow/dominance.ts b/src/dataflow/dominance.ts
new file mode 100644
index 0000000..9851e19
--- /dev/null
+++ b/src/dataflow/dominance.ts
@@ -0,0 +1,140 @@
+/**
+ * Stage 2 — post-dominators and control dependence.
+ *
+ * Post-dominators via the Cooper–Harper–Kennedy iterative algorithm run on the REVERSE CFG
+ * rooted at EXIT. Control dependence via Ferrante–Ottenstein–Warren: for each CFG edge (a, b)
+ * where b does not post-dominate a, every node from b up the post-dominator tree to (exclusive)
+ * ipdom(a) is control-dependent on a.
+ *
+ * The CFG is augmented with the standard ENTRY → EXIT edge for this computation only, so
+ * straight-line statements come out control-dependent on ENTRY (the function's outermost
+ * control region). The augmented edge is never emitted.
+ *
+ * Infinite loops need no special-casing here: stage 1 always emits the loop-exit `false` edge
+ * (even when the condition is literally `true`), which keeps EXIT the unique post-dominance root.
+ */
+import type { PdgEdge } from "../schema";
+import type { FunctionCfgBuild } from "./model";
+
+/** Immediate post-dominator per node id (EXIT maps to itself). */
+export function postDominators(build: FunctionCfgBuild): Map<number, number> {
+  const { exitId } = build;
+  const edges = augmentedEdges(build);
+  // Reverse-CFG adjacency: from EXIT we walk against the CFG edges.
+  const predOfReverse = new Map<number, number[]>(); // reverse-graph successors = CFG predecessors
+  for (const n of build.nodes) predOfReverse.set(n.id, []);
+  for (const [a, b] of edges) predOfReverse.get(b)?.push(a); // in the reverse graph, b → a
+
+  // Postorder of the reverse graph from EXIT (iterative DFS).
+  const postorder: number[] = [];
+  const poNum = new Map<number, number>();
+  const visited = new Set<number>([exitId]);
+  const stack: Array<{ node: number; next: number }> = [{ node: exitId, next: 0 }];
+  while (stack.length) {
+    const top = stack[stack.length - 1] as { node: number; next: number };
+    const kids = predOfReverse.get(top.node) as number[];
+    if (top.next < kids.length) {
+      const k = kids[top.next++] as number;
+      if (!visited.has(k)) {
+        visited.add(k);
+        stack.push({ node: k, next: 0 });
+      }
+    } else {
+      poNum.set(top.node, postorder.length);
+      postorder.push(top.node);
+      stack.pop();
+    }
+  }
+
+  const ipdom = new Map<number, number>();
+  ipdom.set(exitId, exitId);
+  const intersect = (u: number, v: number): number => {
+    let a = u;
+    let b = v;
+    while (a !== b) {
+      while ((poNum.get(a) as number) < (poNum.get(b) as number)) a = ipdom.get(a) as number;
+      while ((poNum.get(b) as number) < (poNum.get(a) as number)) b = ipdom.get(b) as number;
+    }
+    return a;
+  };
+
+  // Successor adjacency (CFG direction), for the intersect step.
+  const cfgSucc = new Map<number, number[]>();
+  for (const n of build.nodes) cfgSucc.set(n.id, []);
+  for (const [a, b] of edges) cfgSucc.get(a)?.push(b);
+
+  // Iterate to fixpoint in reverse postorder (of the reverse graph).
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (let i = postorder.length - 1; i >= 0; i--) {
+      const n = postorder[i] as number;
+      if (n === exitId) continue;
+      // "Predecessors" in the reverse graph = CFG successors that already have an ipdom.
+      let candidate = -1;
+      for (const s of cfgSucc.get(n) ?? []) {
+        if (!ipdom.has(s) || !poNum.has(s)) continue;
+        candidate = candidate === -1 ? s : intersect(candidate, s);
+      }
+      if (candidate !== -1 && ipdom.get(n) !== candidate) {
+        ipdom.set(n, candidate);
+        changed = true;
+      }
+    }
+  }
+  return ipdom;
+}
+
+/** Does `b` strictly post-dominate `a`? (walks a's ipdom chain) */
+function strictlyPostDominates(b: number, a: number, ipdom: Map<number, number>, exitId: number): boolean {
+  if (a === b) return false;
+  let cur = ipdom.get(a);
+  const seen = new Set<number>();
+  while (cur !== undefined && !seen.has(cur)) {
+    if (cur === b) return true;
+    if (cur === exitId) return b === exitId;
+    seen.add(cur);
+    cur = ipdom.get(cur);
+  }
+  return false;
+}
+
+/** Ferrante–Ottenstein–Warren control-dependence edges (branch node → dependent node). */
+export function controlDependence(build: FunctionCfgBuild, ipdom: Map<number, number>): PdgEdge[] {
+  const out: PdgEdge[] = [];
+  const seen = new Set<string>();
+  for (const [a, b] of augmentedEdges(build)) {
+    const ia = ipdom.get(a);
+    if (ia === undefined || !ipdom.has(b)) continue; // node can't reach EXIT — skip (gate-checked)
+    if (b === ia || strictlyPostDominates(b, a, ipdom, build.exitId)) continue;
+    let runner = b;
+    let guard = build.nodes.length + 1;
+    while (runner !== ia && guard-- > 0) {
+      const k = `${a}>${runner}`;
+      if (!seen.has(k) && a !== runner) {
+        seen.add(k);
+        out.push({ source: a, target: runner, type: "CDG" });
+      }
+      runner = ipdom.get(runner) as number;
+    }
+  }
+  return out;
+}
+
+// --- helpers ---
+
+/** CFG edges as (source, target) pairs, deduped, plus the augmented ENTRY → EXIT edge. */
+function augmentedEdges(build: FunctionCfgBuild): Array<[number, number]> {
+  const seen = new Set<string>();
+  const out: Array<[number, number]> = [];
+  const push = (a: number, b: number): void => {
+    const k = `${a}>${b}`;
+    if (seen.has(k)) return;
+    seen.add(k);
+    out.push([a, b]);
+  };
+  for (const e of build.edges) push(e.source, e.target);
+  push(build.entryId, build.exitId);
+  return out;
+}
+
diff --git a/src/dataflow/index.ts b/src/dataflow/index.ts
new file mode 100644
index 0000000..d3a27ce
--- /dev/null
+++ b/src/dataflow/index.ts
@@ -0,0 +1,259 @@
+/**
+ * Level 3 — the program-graphs pipeline (stages 1–7 of the dataflow contract), run only at
+ * `-a 3` after the symbol table and call graph exist:
+ *
+ *   identity map (signature → AST callable)         — the same signatureOf() canonicalizer
+ *   → stage 1  CFG per callable                     (cfg.ts)
+ *   → stage 2  post-dominance + control dependence  (dominance.ts)
+ *   → stage 3  access paths + reaching defs → DDG   (defuse.ts, re-run inside the fixpoint)
+ *   → stage 5  SCC condensation of the call graph   (summaries.ts)
+ *   → stage 6  bottom-up relational summaries       (summaries.ts)
+ *   → stage 4+7  PDG assembly + SDG edges           (here + sdg.ts)
+ *   → emission of the `program_graphs` section, scoped by `--graphs`
+ *
+ * Determinism: callables are processed in sorted-signature order, node ids are source-span
+ * ordered, and every edge list is collect-then-sorted before emission.
+ *
+ * Summaries (with their callee dependency edges and the owning module's content hash) are
+ * persisted to `<cache_dir>/graphs_summaries.json` — recorded from day one so incremental
+ * re-analysis can later consume them; nothing reads them yet.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Node, ts, type Project, type SourceFile } from "ts-morph";
+import type { AnalysisOptions } from "../options";
+import {
+  PROGRAM_GRAPHS_SCHEMA_VERSION,
+  computeSignatureForDecl,
+  type FunctionGraphs,
+  type GraphNode,
+  type PdgEdge,
+  type ProgramGraphs,
+  type TSCallable,
+  type TSCallsite,
+  type TSClass,
+  type TSModule,
+  type TSNamespace,
+} from "../schema";
+import type { Logger } from "../utils";
+import { buildCfg } from "./cfg";
+import { controlDependence, postDominators } from "./dominance";
+import type { FunctionCfgBuild } from "./model";
+import { type CallSiteRef, composeSummaries } from "./summaries";
+import { assembleSdg } from "./sdg";
+
+export { backwardSlice, type SliceCriterion } from "./slice";
+
+export interface BuildGraphsArgs {
+  project: Project;
+  symbol_table: Record<string, TSModule>;
+  opts: AnalysisOptions;
+  log: Logger;
+}
+
+export function buildProgramGraphs({ project, symbol_table, opts, log }: BuildGraphsArgs): ProgramGraphs {
+  const k = opts.graphFieldDepth;
+  const root = opts.input;
+
+  // ---- identity map: canonical signature → the function-like AST node that owns the body ----
+  const astIndex = indexCallableDecls(project, root);
+
+  // ---- collect symbol-table callables (the node universe) ----
+  const callables = new Map<string, TSCallable>();
+  for (const mod of Object.values(symbol_table)) collectModule(mod, callables);
+
+  // ---- stage 1: CFGs, in deterministic signature order ----
+  const builds = new Map<string, FunctionCfgBuild>();
+  for (const sig of [...callables.keys()].sort()) {
+    const fn = astIndex.get(sig);
+    if (!fn) continue; // bodiless (interface/abstract/ambient/implicit) or unmatchable
+    const build = buildCfg(sig, fn);
+    if (build) builds.set(sig, build);
+  }
+  log.info(`program graphs: ${builds.size} callables (of ${callables.size} in the symbol table)`);
+
+  // ---- map recorded call sites onto CFG statement nodes ----
+  const callSites = new Map<string, CallSiteRef[]>();
+  for (const [sig, build] of builds) {
+    const refs: CallSiteRef[] = [];
+    for (const site of (callables.get(sig) as TSCallable).call_sites) {
+      const nodeId = containingNode(build, site);
+      if (nodeId === null) continue;
+      refs.push({ nodeId, callee: site.callee_signature, argCount: site.argument_types.length });
+    }
+    refs.sort((a, b) => a.nodeId - b.nodeId || (a.callee ?? "").localeCompare(b.callee ?? ""));
+    callSites.set(sig, refs);
+  }
+
+  // ---- stages 5–6: SCC condensation + summary fixpoint (re-runs stage 3 per iteration) ----
+  const { summaries, defUse, sccs } = composeSummaries(builds, callSites, root, k, log);
+  log.debug(`program graphs: ${sccs.length} SCCs, largest ${Math.max(0, ...sccs.map((s) => s.length))}`);
+
+  // ---- stages 2 + 4: control dependence, PDG assembly; emission per --graphs selector ----
+  const wantCfg = opts.graphs.includes("cfg");
+  const wantPdg = opts.graphs.includes("pdg");
+  const wantDfg = opts.graphs.includes("dfg");
+  const wantSdg = opts.graphs.includes("sdg");
+
+  const functions: Record<string, FunctionGraphs> = {};
+  for (const [sig, build] of [...builds.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    const fg: FunctionGraphs = {};
+    if (wantCfg) {
+      fg.cfg = {
+        nodes: build.nodes.map((n) => emitNode(n.id, n.kind, n.ast, build)),
+        edges: [...build.edges].sort((a, b) => a.source - b.source || a.target - b.target || a.kind.localeCompare(b.kind)),
+      };
+    }
+    if (wantPdg || wantDfg) {
+      const edges: PdgEdge[] = [];
+      if (wantPdg) edges.push(...controlDependence(build, postDominators(build)));
+      edges.push(...(defUse.get(sig)?.ddg ?? []));
+      fg.pdg = {
+        edges: edges.sort(
+          (a, b) =>
+            a.source - b.source || a.target - b.target || a.type.localeCompare(b.type) || (a.var ?? "").localeCompare(b.var ?? ""),
+        ),
+      };
+    }
+    functions[sig] = fg;
+  }
+
+  const sdg_edges = wantSdg ? assembleSdg(builds, callSites, summaries) : [];
+
+  persistSummaries(opts, symbol_table, callables, summaries, k, log);
+
+  return { schema_version: PROGRAM_GRAPHS_SCHEMA_VERSION, k_limit: k, functions, sdg_edges };
+}
+
+// ------------------------------------------------------------------------------------------------
+// Identity mapping
+// ------------------------------------------------------------------------------------------------
+
+/**
+ * Walk every project source file and index callable declarations by canonical signature — the
+ * same computeSignatureForDecl the symbol table and call graph use, so keys byte-match. For
+ * `const f = () => {}` the signature keys the VariableDeclaration but the CFG is built from the
+ * initializer (the node that owns parameters and body).
+ */
+function indexCallableDecls(project: Project, root: string): Map<string, Node> {
+  const idx = new Map<string, Node>();
+  for (const sf of project.getSourceFiles()) {
+    const fp = sf.getFilePath();
+    if (sf.isDeclarationFile() || fp.includes("/node_modules/")) continue;
+    sf.forEachDescendant((n) => {
+      if (
+        Node.isFunctionDeclaration(n) ||
+        Node.isMethodDeclaration(n) ||
+        Node.isConstructorDeclaration(n) ||
+        Node.isGetAccessorDeclaration(n) ||
+        Node.isSetAccessorDeclaration(n)
+      ) {
+        const sig = computeSignatureForDecl(n, root);
+        if (sig && !idx.has(sig)) idx.set(sig, n);
+      } else if (Node.isVariableDeclaration(n)) {
+        const init = n.getInitializer();
+        if (init && (Node.isArrowFunction(init) || Node.isFunctionExpression(init))) {
+          const sig = computeSignatureForDecl(n, root);
+          if (sig && !idx.has(sig)) idx.set(sig, init);
+        }
+      }
+    });
+  }
+  return idx;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Call-site → CFG-node mapping
+// ------------------------------------------------------------------------------------------------
+
+/** The innermost CFG node whose AST span contains the recorded call site, or null. */
+function containingNode(build: FunctionCfgBuild, site: TSCallsite): number | null {
+  const pos = positionOf(build.sf, site.start_line, site.start_column);
+  if (pos === null) return null;
+  let best: { id: number; len: number } | null = null;
+  for (const n of build.nodes) {
+    if (!n.ast) continue;
+    const start = n.ast.getStart();
+    const end = n.ast.getEnd();
+    if (pos < start || pos >= end) continue;
+    const len = end - start;
+    if (!best || len < best.len) best = { id: n.id, len };
+  }
+  return best?.id ?? null;
+}
+
+function positionOf(sf: SourceFile, line: number, column: number): number | null {
+  try {
+    return ts.getPositionOfLineAndCharacter(sf.compilerNode, line - 1, column - 1);
+  } catch {
+    return null;
+  }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Emission helpers
+// ------------------------------------------------------------------------------------------------
+
+function emitNode(id: number, kind: GraphNode["kind"], ast: Node | null, build: FunctionCfgBuild): GraphNode {
+  const target = ast ?? build.fn; // ENTRY/EXIT carry the whole callable's span
+  const s = build.sf.getLineAndColumnAtPos(target.getStart());
+  const e = build.sf.getLineAndColumnAtPos(target.getEnd());
+  return { id, kind, start_line: s.line, start_column: s.column, end_line: e.line, end_column: e.column };
+}
+
+// ------------------------------------------------------------------------------------------------
+// Summary persistence (dependency-recorded, for later incrementality; write-only today)
+// ------------------------------------------------------------------------------------------------
+
+function persistSummaries(
+  opts: AnalysisOptions,
+  symbol_table: Record<string, TSModule>,
+  callables: Map<string, TSCallable>,
+  summaries: Map<string, import("./summaries").FunctionSummary>,
+  k: number,
+  log: Logger,
+): void {
+  try {
+    const cacheDir = opts.cacheDir ?? path.join(opts.input, ".codeanalyzer");
+    fs.mkdirSync(cacheDir, { recursive: true });
+    const entries: Record<string, unknown> = {};
+    for (const sig of [...summaries.keys()].sort()) {
+      const c = callables.get(sig);
+      entries[sig] = {
+        ...summaries.get(sig),
+        content_hash: (c && symbol_table[c.path]?.content_hash) ?? null,
+      };
+    }
+    const payload = { schema_version: PROGRAM_GRAPHS_SCHEMA_VERSION, k_limit: k, summaries: entries };
+    fs.writeFileSync(path.join(cacheDir, "graphs_summaries.json"), JSON.stringify(payload, null, 2));
+  } catch (e) {
+    log.warn(`could not persist graph summaries: ${(e as Error).message}`);
+  }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Symbol-table collection (signature → callable), recursing through every container kind
+// ------------------------------------------------------------------------------------------------
+
+function collectModule(mod: TSModule, out: Map<string, TSCallable>): void {
+  for (const f of Object.values(mod.functions)) collectCallable(f, out);
+  for (const c of Object.values(mod.classes)) collectClass(c, out);
+  for (const ns of Object.values(mod.namespaces)) collectNamespace(ns, out);
+}
+
+function collectNamespace(ns: TSNamespace, out: Map<string, TSCallable>): void {
+  for (const f of Object.values(ns.functions)) collectCallable(f, out);
+  for (const c of Object.values(ns.classes)) collectClass(c, out);
+  for (const n of Object.values(ns.namespaces)) collectNamespace(n, out);
+}
+
+function collectClass(c: TSClass, out: Map<string, TSCallable>): void {
+  for (const m of Object.values(c.methods)) collectCallable(m, out);
+  for (const ic of Object.values(c.inner_classes)) collectClass(ic, out);
+}
+
+function collectCallable(c: TSCallable, out: Map<string, TSCallable>): void {
+  out.set(c.signature, c);
+  for (const ic of Object.values(c.inner_callables)) collectCallable(ic, out);
+  for (const cl of Object.values(c.inner_classes)) collectClass(cl, out);
+}
diff --git a/src/dataflow/model.ts b/src/dataflow/model.ts
new file mode 100644
index 0000000..663dad0
--- /dev/null
+++ b/src/dataflow/model.ts
@@ -0,0 +1,44 @@
+/**
+ * Internal (non-emitted) working model shared by the level-3 dataflow stages. The emitted shapes
+ * live in schema/graphs.ts; everything here additionally keeps the ts-morph AST links the later
+ * stages (def-use, summaries, SDG) need, and is dropped before serialization.
+ */
+import type { Node, SourceFile } from "ts-morph";
+import type { CfgEdge, GraphNodeKind } from "../schema";
+
+/** A CFG node with its AST link. `ast` is null only for the synthetic ENTRY/EXIT pair. */
+export interface DfNode {
+  id: number;
+  kind: GraphNodeKind;
+  ast: Node | null;
+}
+
+/** The per-callable CFG build product (stage 1), input to every later stage. */
+export interface FunctionCfgBuild {
+  signature: string;
+  /** The function-like AST node (FunctionDeclaration / Method / Ctor / accessor / arrow / fn-expr). */
+  fn: Node;
+  sf: SourceFile;
+  /** Ordered by id; nodes[0] is ENTRY, nodes[nodes.length - 1] is EXIT. */
+  nodes: DfNode[];
+  edges: CfgEdge[];
+  entryId: number;
+  exitId: number;
+  /** node ids of the `param` nodes, in declaration order (the SDG formal-in nodes). */
+  paramIds: number[];
+}
+
+/** Successor/predecessor adjacency over CFG edges, built on demand. */
+export function adjacency(build: FunctionCfgBuild): { succ: Map<number, number[]>; pred: Map<number, number[]> } {
+  const succ = new Map<number, number[]>();
+  const pred = new Map<number, number[]>();
+  for (const n of build.nodes) {
+    succ.set(n.id, []);
+    pred.set(n.id, []);
+  }
+  for (const e of build.edges) {
+    succ.get(e.source)?.push(e.target);
+    pred.get(e.target)?.push(e.source);
+  }
+  return { succ, pred };
+}
diff --git a/src/dataflow/sdg.ts b/src/dataflow/sdg.ts
new file mode 100644
index 0000000..696c7a3
--- /dev/null
+++ b/src/dataflow/sdg.ts
@@ -0,0 +1,120 @@
+/**
+ * Stage 7 — SDG assembly: stitch the per-function PDGs with interprocedural edges
+ * (Horwitz–Reps–Binkley), all keyed by canonical `(signature, node_id)`.
+ *
+ * Call sites are collapsed onto their containing statement node (the node is both actual-in and
+ * actual-out), so:
+ *  - CALL:      callsite statement → callee ENTRY (node 0).
+ *  - PARAM_IN:  callsite statement → callee `param` node, var "argN"; module globals the callee
+ *               transitively reads ride the same mechanism targeting the callee ENTRY (where
+ *               stage 3 places their initial defs), var = the global path.
+ *  - PARAM_OUT: callee EXIT → callsite statement, var "return" (always: over-approximate) or the
+ *               written global path.
+ *  - SUMMARY:   self-edge on the callsite node, var = the input ("argN" or a global path) whose
+ *               value may transitively flow to the call's result — composed from stage 6.
+ *
+ * External / unresolved callees have no graphs to reference (no dangling endpoints — the
+ * call-graph rule), so they contribute only conservative pass-through SUMMARY self-edges.
+ */
+import { Node } from "ts-morph";
+import type { SdgEdge } from "../schema";
+import type { FunctionCfgBuild } from "./model";
+import type { CallSiteRef, FunctionSummary } from "./summaries";
+import { renderGlobal } from "./defuse";
+
+export function assembleSdg(
+  builds: Map<string, FunctionCfgBuild>,
+  callSites: Map<string, CallSiteRef[]>,
+  summaries: Map<string, FunctionSummary>,
+): SdgEdge[] {
+  const out: SdgEdge[] = [];
+  const seen = new Set<string>();
+  const add = (e: SdgEdge): void => {
+    const k = `${e.source.signature}#${e.source.node}>${e.target.signature}#${e.target.node}>${e.type}>${e.var ?? ""}`;
+    if (seen.has(k)) return;
+    seen.add(k);
+    out.push(e);
+  };
+
+  for (const caller of [...builds.keys()].sort()) {
+    for (const cs of callSites.get(caller) ?? []) {
+      const at = (node: number): { signature: string; node: number } => ({ signature: caller, node });
+      const callee = cs.callee ? builds.get(cs.callee) : undefined;
+
+      if (!callee || !cs.callee) {
+        // External / unresolved: conservative pass-through — every argument may flow to the result.
+        for (let i = 0; i < cs.argCount; i++) {
+          add({ source: at(cs.nodeId), target: at(cs.nodeId), type: "SUMMARY", var: `arg${i}` });
+        }
+        continue;
+      }
+
+      const calleeSig = cs.callee;
+      add({ source: at(cs.nodeId), target: { signature: calleeSig, node: callee.entryId }, type: "CALL" });
+
+      // Positional PARAM_IN edges; extra arguments bind to a trailing rest parameter if there is one.
+      const rest = hasRestParam(callee);
+      for (let i = 0; i < cs.argCount; i++) {
+        let pIdx = i;
+        if (pIdx >= callee.paramIds.length) {
+          if (!rest || callee.paramIds.length === 0) continue;
+          pIdx = callee.paramIds.length - 1;
+        }
+        add({
+          source: at(cs.nodeId),
+          target: { signature: calleeSig, node: callee.paramIds[pIdx] as number },
+          type: "PARAM_IN",
+          var: `arg${i}`,
+        });
+      }
+      add({
+        source: { signature: calleeSig, node: callee.exitId },
+        target: at(cs.nodeId),
+        type: "PARAM_OUT",
+        var: "return",
+      });
+
+      const sum = summaries.get(calleeSig);
+      if (sum) {
+        for (const g of sum.global_reads) {
+          add({
+            source: at(cs.nodeId),
+            target: { signature: calleeSig, node: callee.entryId },
+            type: "PARAM_IN",
+            var: renderGlobal(g),
+          });
+        }
+        for (const g of sum.global_writes) {
+          add({
+            source: { signature: calleeSig, node: callee.exitId },
+            target: at(cs.nodeId),
+            type: "PARAM_OUT",
+            var: renderGlobal(g),
+          });
+        }
+        for (const i of sum.param_flows) {
+          if (i < cs.argCount) add({ source: at(cs.nodeId), target: at(cs.nodeId), type: "SUMMARY", var: `arg${i}` });
+        }
+        for (const g of sum.globals_to_return) {
+          add({ source: at(cs.nodeId), target: at(cs.nodeId), type: "SUMMARY", var: g });
+        }
+      }
+    }
+  }
+
+  return out.sort(
+    (a, b) =>
+      a.source.signature.localeCompare(b.source.signature) ||
+      a.source.node - b.source.node ||
+      a.target.signature.localeCompare(b.target.signature) ||
+      a.target.node - b.target.node ||
+      a.type.localeCompare(b.type) ||
+      (a.var ?? "").localeCompare(b.var ?? ""),
+  );
+}
+
+function hasRestParam(build: FunctionCfgBuild): boolean {
+  const params = (build.fn as unknown as { getParameters?: () => Node[] }).getParameters?.() ?? [];
+  const last = params[params.length - 1];
+  return last !== undefined && Node.isParameterDeclaration(last) && last.isRestParameter();
+}
diff --git a/src/dataflow/slice.ts b/src/dataflow/slice.ts
new file mode 100644
index 0000000..2e4b1ff
--- /dev/null
+++ b/src/dataflow/slice.ts
@@ -0,0 +1,69 @@
+/**
+ * Stage 8 client — context-sensitive backward slicing as a query over the emitted SDG
+ * (the two-phase Horwitz–Reps–Binkley traversal).
+ *
+ * Phase 1 ("up"): from the criterion, reverse-traverse intra-function dependence (CDG, DDG),
+ * SUMMARY edges, and the ascending interprocedural edges (PARAM_IN, CALL) — but never PARAM_OUT,
+ * so the walk does not descend into callees (their transitive effects are covered by SUMMARY).
+ * Phase 2 ("down"): from everything phase 1 reached, additionally reverse-traverse PARAM_OUT
+ * (descending into callees), but no longer PARAM_IN/CALL (no re-ascending — that is what keeps
+ * the slice context-sensitive). The slice is the union.
+ */
+import type { ProgramGraphs } from "../schema";
+
+export interface SliceCriterion {
+  signature: string;
+  node: number;
+}
+
+const keyOf = (sig: string, node: number): string => `${sig}#${node}`;
+
+interface ReverseEdges {
+  intra: Map<string, string[]>; // CDG ∪ DDG ∪ SUMMARY, reversed
+  ascend: Map<string, string[]>; // PARAM_IN ∪ CALL, reversed
+  descend: Map<string, string[]>; // PARAM_OUT, reversed
+}
+
+function reverseEdges(pg: ProgramGraphs): ReverseEdges {
+  const intra = new Map<string, string[]>();
+  const ascend = new Map<string, string[]>();
+  const descend = new Map<string, string[]>();
+  const push = (m: Map<string, string[]>, from: string, to: string): void => {
+    const arr = m.get(from) ?? [];
+    arr.push(to);
+    m.set(from, arr);
+  };
+  for (const [sig, g] of Object.entries(pg.functions)) {
+    for (const e of g.pdg?.edges ?? []) push(intra, keyOf(sig, e.target), keyOf(sig, e.source));
+  }
+  for (const e of pg.sdg_edges) {
+    const from = keyOf(e.target.signature, e.target.node);
+    const to = keyOf(e.source.signature, e.source.node);
+    if (e.type === "SUMMARY") push(intra, from, to);
+    else if (e.type === "PARAM_IN" || e.type === "CALL") push(ascend, from, to);
+    else push(descend, from, to);
+  }
+  return { intra, ascend, descend };
+}
+
+export function backwardSlice(pg: ProgramGraphs, criterion: SliceCriterion): Set<string> {
+  const rev = reverseEdges(pg);
+  const walk = (starts: Iterable<string>, follow: Array<Map<string, string[]>>): Set<string> => {
+    const seen = new Set<string>(starts);
+    const stack = [...seen];
+    while (stack.length) {
+      const n = stack.pop() as string;
+      for (const m of follow) {
+        for (const p of m.get(n) ?? []) {
+          if (!seen.has(p)) {
+            seen.add(p);
+            stack.push(p);
+          }
+        }
+      }
+    }
+    return seen;
+  };
+  const phase1 = walk([keyOf(criterion.signature, criterion.node)], [rev.intra, rev.ascend]);
+  return walk(phase1, [rev.intra, rev.descend]);
+}
diff --git a/src/dataflow/summaries.ts b/src/dataflow/summaries.ts
new file mode 100644
index 0000000..15ab21b
--- /dev/null
+++ b/src/dataflow/summaries.ts
@@ -0,0 +1,237 @@
+/**
+ * Stages 5–6 — the interprocedural half: SCC condensation of the (frozen, provenance-merged)
+ * call graph, then bottom-up relational function summaries composed over the condensation DAG.
+ *
+ * A summary answers, per callable: which argument positions flow to the return value, which
+ * module-level globals it (transitively) reads and writes, and which globals flow to its return.
+ * Summaries are node-granular — dependence is tracked between CFG nodes, not sub-expressions —
+ * which keeps them sound-leaning and over-approximate (the contract's precision posture).
+ *
+ * Composition order is Tarjan's SCC emission order (callees before callers). Within an SCC
+ * (mutual recursion), member summaries are co-defined: each member's def-use is recomputed with
+ * the current callee summaries applied at its call sites (globals become extra uses/defs on the
+ * callsite node), iterating to a monotone fixpoint. Termination: summary domains are finite —
+ * argument indices are bounded by arity and global paths are k-limited — and grow monotonically.
+ *
+ * External / unresolved callees: conservative pass-through — every argument may flow to the
+ * result (applied at SDG/SUMMARY emission); their global effects are unmodeled (documented
+ * unsoundness: npm internals are not analyzed).
+ */
+import type { Logger } from "../utils";
+import { type CallEffects, type DefUseResult, type GlobalPath, computeDefUse, renderGlobal } from "./defuse";
+import type { FunctionCfgBuild } from "./model";
+
+/** A call site inside a callable, mapped onto its CFG statement node. */
+export interface CallSiteRef {
+  nodeId: number;
+  /** Callee signature (symbol-table / external / synthesized key), or null when unresolved. */
+  callee: string | null;
+  argCount: number;
+}
+
+export interface FunctionSummary {
+  /** Argument indices whose value may flow to the return value. */
+  param_flows: number[];
+  global_reads: GlobalPath[];
+  global_writes: GlobalPath[];
+  /** Rendered global paths that may flow to the return value. */
+  globals_to_return: string[];
+  /** Callee signatures this summary was composed from (recorded for later incrementality). */
+  deps: string[];
+}
+
+export interface SummaryResult {
+  summaries: Map<string, FunctionSummary>;
+  /** The fixpoint def-use per callable (its DDG already reflects callee global effects). */
+  defUse: Map<string, DefUseResult>;
+  /** SCCs in composition (reverse-topological, callees-first) order — exposed for tests. */
+  sccs: string[][];
+}
+
+export function composeSummaries(
+  builds: Map<string, FunctionCfgBuild>,
+  callSites: Map<string, CallSiteRef[]>,
+  root: string,
+  k: number,
+  log: Logger,
+): SummaryResult {
+  const sigs = [...builds.keys()].sort();
+  const adj = new Map<string, string[]>();
+  for (const s of sigs) {
+    const targets = new Set<string>();
+    for (const cs of callSites.get(s) ?? []) {
+      if (cs.callee && builds.has(cs.callee) && cs.callee !== s) targets.add(cs.callee);
+    }
+    adj.set(s, [...targets].sort());
+  }
+
+  const sccs = tarjan(sigs, adj); // emitted callees-first
+  const summaries = new Map<string, FunctionSummary>();
+  const defUse = new Map<string, DefUseResult>();
+
+  for (const scc of sccs) {
+    // Co-define the SCC members' summaries to a fixpoint (a singleton converges in one pass +
+    // one confirmation pass only when it is self-recursive; plain members need a single pass).
+    const members = [...scc].sort();
+    const selfReferential =
+      members.length > 1 ||
+      (callSites.get(members[0] as string) ?? []).some((cs) => cs.callee === members[0]);
+    let iterations = 0;
+    for (;;) {
+      let changed = false;
+      for (const sig of members) {
+        const build = builds.get(sig) as FunctionCfgBuild;
+        const effects = effectsFor(callSites.get(sig) ?? [], summaries);
+        const du = computeDefUse(build, root, k, effects);
+        const next = summarize(build, du, callSites.get(sig) ?? []);
+        if (!summaries.has(sig) || !sameSummary(summaries.get(sig) as FunctionSummary, next)) changed = true;
+        summaries.set(sig, next);
+        defUse.set(sig, du);
+      }
+      iterations++;
+      if (!changed || !selfReferential) break;
+      if (iterations > 100) {
+        log.warn(`summary fixpoint did not settle after ${iterations} iterations for SCC [${members.join(", ")}]`);
+        break;
+      }
+    }
+  }
+  return { summaries, defUse, sccs };
+}
+
+/** Project the current callee summaries onto a function's call sites as global read/write effects. */
+function effectsFor(sites: CallSiteRef[], summaries: Map<string, FunctionSummary>): Map<number, CallEffects> {
+  const out = new Map<number, CallEffects>();
+  for (const cs of sites) {
+    if (!cs.callee) continue;
+    const s = summaries.get(cs.callee);
+    if (!s) continue;
+    const cur = out.get(cs.nodeId) ?? { reads: [], writes: [] };
+    cur.reads.push(...s.global_reads);
+    cur.writes.push(...s.global_writes);
+    out.set(cs.nodeId, cur);
+  }
+  return out;
+}
+
+function summarize(build: FunctionCfgBuild, du: DefUseResult, _sites: CallSiteRef[]): FunctionSummary {
+  // Forward DDG adjacency (def-node → use-node = "use-node depends on def-node").
+  const fwd = new Map<number, Set<number>>();
+  for (const e of du.ddg) {
+    if (!fwd.has(e.source)) fwd.set(e.source, new Set());
+    fwd.get(e.source)?.add(e.target);
+  }
+  const reaches = (starts: number[]): Set<number> => {
+    const seen = new Set<number>(starts);
+    const stack = [...starts];
+    while (stack.length) {
+      const n = stack.pop() as number;
+      for (const s of fwd.get(n) ?? []) {
+        if (!seen.has(s)) {
+          seen.add(s);
+          stack.push(s);
+        }
+      }
+    }
+    return seen;
+  };
+  const touchesReturn = (starts: number[]): boolean => {
+    for (const n of reaches(starts)) if (du.returnValueNodes.has(n)) return true;
+    return false;
+  };
+
+  const param_flows: number[] = [];
+  for (const [i, pid] of build.paramIds.entries()) {
+    if (touchesReturn([pid])) param_flows.push(i);
+  }
+
+  // Global reads/writes: module-kind uses/defs anywhere in the function. Callee effects were
+  // already injected into the facts by computeDefUse, so transitive effects fall out for free.
+  // ENTRY's synthetic ambient defs are initializations, not writes — exclude them.
+  const readsByKey = new Map<string, GlobalPath>();
+  const writesByKey = new Map<string, GlobalPath>();
+  const usedAt = new Map<string, number[]>();
+  for (const [nodeId, f] of du.facts) {
+    for (const u of f.uses) {
+      if (u.baseKind !== "module") continue;
+      const g: GlobalPath = { key: u.key, fields: u.fields };
+      readsByKey.set(renderGlobal(g), g);
+      const arr = usedAt.get(u.key) ?? [];
+      arr.push(nodeId);
+      usedAt.set(u.key, arr);
+    }
+    if (nodeId === build.entryId) continue;
+    for (const d of f.defs) {
+      if (d.ref.baseKind !== "module") continue;
+      const g: GlobalPath = { key: d.ref.key, fields: d.ref.fields };
+      writesByKey.set(renderGlobal(g), g);
+    }
+  }
+
+  const globals_to_return: string[] = [];
+  for (const [rendered, g] of readsByKey) {
+    const nodes = usedAt.get(g.key) ?? [];
+    if (nodes.length && touchesReturn(nodes)) globals_to_return.push(rendered);
+  }
+
+  const deps = new Set<string>();
+  for (const cs of _sites) if (cs.callee) deps.add(cs.callee);
+
+  return {
+    param_flows: param_flows.sort((a, b) => a - b),
+    global_reads: sortGlobals([...readsByKey.values()]),
+    global_writes: sortGlobals([...writesByKey.values()]),
+    globals_to_return: globals_to_return.sort(),
+    deps: [...deps].sort(),
+  };
+}
+
+function sortGlobals(gs: GlobalPath[]): GlobalPath[] {
+  return gs.sort((a, b) => renderGlobal(a).localeCompare(renderGlobal(b)));
+}
+
+function sameSummary(a: FunctionSummary, b: FunctionSummary): boolean {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Tarjan SCC — emission order is reverse-topological (an SCC is emitted after every SCC it calls).
+// ------------------------------------------------------------------------------------------------
+
+function tarjan(nodes: string[], adj: Map<string, string[]>): string[][] {
+  const index = new Map<string, number>();
+  const low = new Map<string, number>();
+  const onStack = new Set<string>();
+  const stack: string[] = [];
+  const out: string[][] = [];
+  let counter = 0;
+
+  const strongconnect = (v: string): void => {
+    index.set(v, counter);
+    low.set(v, counter);
+    counter++;
+    stack.push(v);
+    onStack.add(v);
+    for (const w of adj.get(v) ?? []) {
+      if (!index.has(w)) {
+        strongconnect(w);
+        low.set(v, Math.min(low.get(v) as number, low.get(w) as number));
+      } else if (onStack.has(w)) {
+        low.set(v, Math.min(low.get(v) as number, index.get(w) as number));
+      }
+    }
+    if (low.get(v) === index.get(v)) {
+      const scc: string[] = [];
+      for (;;) {
+        const w = stack.pop() as string;
+        onStack.delete(w);
+        scc.push(w);
+        if (w === v) break;
+      }
+      out.push(scc);
+    }
+  };
+
+  for (const v of nodes) if (!index.has(v)) strongconnect(v);
+  return out;
+}
diff --git a/src/options/options.ts b/src/options/options.ts
index db83fbb..1b711c2 100644
--- a/src/options/options.ts
+++ b/src/options/options.ts
@@ -1,3 +1,5 @@
+import type { GraphSelector } from "../schema";
+
 export type EmitTarget = "json" | "neo4j" | "schema";
 export type CallGraphProviderName = "union" | "tsc" | "jelly";
 
@@ -16,8 +18,15 @@ export interface AnalysisOptions {
   neo4jUser: string;
   neo4jPassword: string;
   neo4jDatabase: string | null;
-  /** Analysis depth requested by the caller (1 = symbol table + call graph [default]; 2 = call graph). */
-  analysisLevel: 1 | 2;
+  /**
+   * Analysis depth requested by the caller (1 = symbol table + call graph [default];
+   * 2 = call graph; 3 = + native program graphs — CFG/PDG/SDG in `program_graphs`).
+   */
+  analysisLevel: 1 | 2 | 3;
+  /** Which level-3 graph sections to emit (`--graphs`); only consulted at level 3. */
+  graphs: GraphSelector[];
+  /** k-limit for access-path depth in the level-3 dataflow (`--graph-field-depth`, default 3). */
+  graphFieldDepth: number;
   /** Restrict analysis to these files (project-relative or absolute). null ⇒ whole project. */
   targetFiles: string[] | null;
   /** Skip test trees (default true). */
diff --git a/src/schema/graphs.ts b/src/schema/graphs.ts
new file mode 100644
index 0000000..801eb5c
--- /dev/null
+++ b/src/schema/graphs.ts
@@ -0,0 +1,131 @@
+/**
+ * The level-3 `program_graphs` contract — CFG / PDG (CDG+DDG) / SDG, per the cross-language
+ * dataflow-graphs spec. Emitted as an optional top-level section of analysis.json, only at
+ * `-a 3`, scoped by `--graphs`.
+ *
+ * Node identity is the invariant that makes everything joinable: every node is keyed by
+ * `(signature, node_id)` where `signature` is the SAME signatureOf() key used by symbol_table
+ * and call_graph, and `node_id` is the index of the owning AST node in source-span order within
+ * the callable (synthetic ENTRY = 0, EXIT = last). Cross-function edges reference both endpoints
+ * that way, and — as with the call graph — may never dangle.
+ *
+ * The node-kind / edge-kind vocabulary below is shared across the CLDK analyzers (parity
+ * clause); TS-specific members (`await_resume`, `yield`) are additive and recorded in
+ * .claude/SCHEMA_DECISIONS.md.
+ */
+
+// Bumped independently of the top-level schema; additive changes only.
+export const PROGRAM_GRAPHS_SCHEMA_VERSION = "1.0.0";
+
+// ----------------------------------------------------------------------------------------------
+// Nodes
+// ----------------------------------------------------------------------------------------------
+
+/**
+ * CFG node kinds. `entry`/`exit` are synthetic (span = the whole callable); `param` nodes are the
+ * formal-in nodes of the SDG (span = the parameter declaration); everything else is `statement`.
+ */
+export type GraphNodeKind = "entry" | "exit" | "param" | "statement";
+
+export interface GraphNode {
+  id: number;
+  kind: GraphNodeKind;
+  start_line: number;
+  start_column: number;
+  end_line: number;
+  end_column: number;
+}
+
+// ----------------------------------------------------------------------------------------------
+// Intra-function edges
+// ----------------------------------------------------------------------------------------------
+
+/** CFG_NEXT edge kinds — the shared vocabulary plus the TS-native `await_resume` / `yield`. */
+export type CfgEdgeKind =
+  | "fallthrough"
+  | "true"
+  | "false"
+  | "switch_case"
+  | "loop_back"
+  | "exception"
+  | "return"
+  | "break"
+  | "continue"
+  | "yield"
+  | "await_resume";
+
+export interface CfgEdge {
+  source: number;
+  target: number;
+  kind: CfgEdgeKind;
+}
+
+/** PDG edge: control dependence (CDG) or data dependence (DDG, labeled with the access path). */
+export interface PdgEdge {
+  source: number;
+  target: number;
+  type: "CDG" | "DDG";
+  /** The k-limited access path the dependence carries (DDG only). */
+  var?: string;
+}
+
+export interface FunctionCfg {
+  nodes: GraphNode[];
+  edges: CfgEdge[];
+}
+
+export interface FunctionPdg {
+  edges: PdgEdge[];
+}
+
+/** The per-callable graphs, keyed by the callable's canonical signature in `functions`. */
+export interface FunctionGraphs {
+  cfg?: FunctionCfg;
+  pdg?: FunctionPdg;
+}
+
+// ----------------------------------------------------------------------------------------------
+// Cross-function (SDG) edges
+// ----------------------------------------------------------------------------------------------
+
+export interface SdgEndpoint {
+  signature: string;
+  node: number;
+}
+
+/**
+ * SDG edge types (Horwitz–Reps–Binkley):
+ *  - CALL       callsite statement → callee ENTRY.
+ *  - PARAM_IN   callsite statement → callee `param` node (`var` = "argN"), or → callee ENTRY for
+ *               a module/global binding the callee transitively reads (`var` = the global path).
+ *  - PARAM_OUT  callee EXIT → callsite statement (`var` = "return", or the global path written).
+ *  - SUMMARY    actual-in → actual-out at the same call site. Call sites are collapsed onto their
+ *               containing statement node, so SUMMARY edges are self-edges on the callsite node;
+ *               `var` names the input ("argN" or a global path) that transitively flows to the
+ *               call's result.
+ */
+export type SdgEdgeType = "CALL" | "PARAM_IN" | "PARAM_OUT" | "SUMMARY";
+
+export interface SdgEdge {
+  source: SdgEndpoint;
+  target: SdgEndpoint;
+  type: SdgEdgeType;
+  var?: string;
+}
+
+// ----------------------------------------------------------------------------------------------
+// Root section
+// ----------------------------------------------------------------------------------------------
+
+export interface ProgramGraphs {
+  schema_version: string;
+  /** The access-path depth bound (--graph-field-depth) the graphs were built with. */
+  k_limit: number;
+  functions: Record<string, FunctionGraphs>;
+  /** Cross-function edges only; intra-function edges live in each function's pdg. */
+  sdg_edges: SdgEdge[];
+}
+
+/** The `--graphs` selector values. `dfg` = the DDG subset of the PDG (no separate section). */
+export type GraphSelector = "cfg" | "dfg" | "pdg" | "sdg";
+export const ALL_GRAPHS: GraphSelector[] = ["cfg", "dfg", "pdg", "sdg"];
diff --git a/src/schema/index.ts b/src/schema/index.ts
index 9de570f..fde1c87 100644
--- a/src/schema/index.ts
+++ b/src/schema/index.ts
@@ -2,3 +2,4 @@
 // syntactic and semantic phases).
 export * from "./schema";
 export * from "./signatures";
+export * from "./graphs";
diff --git a/src/schema/schema.ts b/src/schema/schema.ts
index 056e950..4c75710 100644
--- a/src/schema/schema.ts
+++ b/src/schema/schema.ts
@@ -395,6 +395,8 @@ export interface TSApplication {
   call_graph: TSCallEdge[];
   external_symbols: Record<string, TSExternalSymbol>;
   synthesized_callables: Record<string, TSSynthesizedCallable>;
+  /** Level-3 CFG/PDG/SDG section — present only at `-a 3` (see schema/graphs.ts). */
+  program_graphs?: import("./graphs").ProgramGraphs;
 }
 
 // ==============================================================================================
diff --git a/test/dataflow.test.ts b/test/dataflow.test.ts
new file mode 100644
index 0000000..c957dd6
--- /dev/null
+++ b/test/dataflow.test.ts
@@ -0,0 +1,413 @@
+/**
+ * Level-3 gate tests (issue #2): every verification gate from the dataflow contract, asserted
+ * with exact expected sets on the dataflow-app fixture — CFG, dominance/CDG, DFG, the
+ * PDG backward-slice gate, summaries (SCC fixpoint), SDG (no dangling endpoints), the
+ * interprocedural slice, determinism, and the -a 1/-a 2 gating.
+ */
+import { describe, expect, test } from "bun:test";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { analyze } from "../src/core";
+import { backwardSlice } from "../src/dataflow";
+import type { AnalysisOptions } from "../src/options";
+import type { CfgEdge, FunctionCfg, ProgramGraphs, SdgEdge } from "../src/schema";
+
+const FIXTURE = path.resolve(import.meta.dir, "fixtures/dataflow-app");
+
+function options(level: 1 | 2 | 3, cacheDir: string): AnalysisOptions {
+  return {
+    input: FIXTURE,
+    output: null,
+    emit: "json",
+    appName: null,
+    neo4jUri: null,
+    neo4jUser: "neo4j",
+    neo4jPassword: "",
+    neo4jDatabase: null,
+    analysisLevel: level,
+    graphs: ["cfg", "dfg", "pdg", "sdg"],
+    graphFieldDepth: 3,
+    targetFiles: null,
+    skipTests: true,
+    eager: true,
+    noBuild: true,
+    phantoms: true,
+    callGraphProvider: "tsc",
+    cacheDir,
+    verbosity: 0,
+  };
+}
+
+function run(level: 1 | 2 | 3): ReturnType<typeof analyze> {
+  const cacheDir = fs.mkdtempSync(path.join(os.tmpdir(), "cants-dataflow-test-"));
+  try {
+    return analyze(options(level, cacheDir));
+  } finally {
+    fs.rmSync(cacheDir, { recursive: true, force: true });
+  }
+}
+
+const app = run(3);
+const pg = app.program_graphs as ProgramGraphs;
+
+const cfgOf = (sig: string): FunctionCfg => {
+  const g = pg.functions[sig]?.cfg;
+  if (!g) throw new Error(`no cfg for ${sig}`);
+  return g;
+};
+const pdgOf = (sig: string) => {
+  const g = pg.functions[sig]?.pdg;
+  if (!g) throw new Error(`no pdg for ${sig}`);
+  return g.edges;
+};
+const cdgSet = (sig: string): string[] =>
+  pdgOf(sig)
+    .filter((e) => e.type === "CDG")
+    .map((e) => `${e.source}>${e.target}`)
+    .sort();
+const ddgHas = (sig: string, source: number, target: number, v: string): boolean =>
+  pdgOf(sig).some((e) => e.type === "DDG" && e.source === source && e.target === target && e.var === v);
+const kinds = (sig: string, filter?: (e: CfgEdge) => boolean): CfgEdge[] =>
+  cfgOf(sig).edges.filter(filter ?? (() => true));
+const sdg = (filter: (e: SdgEdge) => boolean): SdgEdge[] => pg.sdg_edges.filter(filter);
+
+// ------------------------------------------------------------------------------------------------
+// CFG gate
+// ------------------------------------------------------------------------------------------------
+
+describe("CFG gate", () => {
+  test("every function: single ENTRY (0) / single EXIT (last), contiguous span-ordered ids", () => {
+    for (const [sig, g] of Object.entries(pg.functions)) {
+      const cfg = g.cfg as FunctionCfg;
+      expect(cfg.nodes.length, sig).toBeGreaterThanOrEqual(2);
+      expect(cfg.nodes[0]?.kind, sig).toBe("entry");
+      expect(cfg.nodes[cfg.nodes.length - 1]?.kind, sig).toBe("exit");
+      cfg.nodes.forEach((n, i) => expect(n.id, sig).toBe(i));
+      expect(cfg.nodes.filter((n) => n.kind === "entry" || n.kind === "exit"), sig).toHaveLength(2);
+    }
+  });
+
+  test("every node maps to a real source span", () => {
+    for (const [sig, g] of Object.entries(pg.functions)) {
+      for (const n of (g.cfg as FunctionCfg).nodes) {
+        expect(n.start_line, sig).toBeGreaterThanOrEqual(1);
+        expect(n.end_line, sig).toBeGreaterThanOrEqual(n.start_line);
+      }
+    }
+  });
+
+  test("every node is reachable from ENTRY and reaches EXIT", () => {
+    for (const [sig, g] of Object.entries(pg.functions)) {
+      const cfg = g.cfg as FunctionCfg;
+      const fwd = new Map<number, number[]>();
+      const rev = new Map<number, number[]>();
+      for (const e of cfg.edges) {
+        fwd.set(e.source, [...(fwd.get(e.source) ?? []), e.target]);
+        rev.set(e.target, [...(rev.get(e.target) ?? []), e.source]);
+      }
+      const bfs = (start: number, adj: Map<number, number[]>): Set<number> => {
+        const seen = new Set([start]);
+        const q = [start];
+        while (q.length) for (const nx of adj.get(q.shift() as number) ?? []) if (!seen.has(nx)) (seen.add(nx), q.push(nx));
+        return seen;
+      };
+      const fromEntry = bfs(0, fwd);
+      const toExit = bfs(cfg.nodes.length - 1, rev);
+      for (const n of cfg.nodes) {
+        expect(fromEntry.has(n.id), `${sig}#${n.id} unreachable from ENTRY`).toBe(true);
+        expect(toExit.has(n.id), `${sig}#${n.id} cannot reach EXIT`).toBe(true);
+      }
+    }
+  });
+
+  test("if/else lowers to true/false branch edges (classify)", () => {
+    const e = kinds("src/flow.classify");
+    expect(e).toContainEqual({ source: 3, target: 4, kind: "true" });
+    expect(e).toContainEqual({ source: 3, target: 5, kind: "false" });
+  });
+
+  test("loops lower with a loop_back edge (sumTo)", () => {
+    expect(kinds("src/flow.sumTo", (e) => e.kind === "loop_back")).not.toHaveLength(0);
+  });
+
+  test("a throwing call inside try edges to the catch node; finally may re-raise (guarded)", () => {
+    const e = kinds("src/flow.guarded");
+    expect(e).toContainEqual({ source: 3, target: 4, kind: "exception" }); // out = parse(s) → catch
+    expect(e).toContainEqual({ source: 6, target: 8, kind: "exception" }); // finally → outward (EXIT)
+  });
+
+  test("throw with no handler edges to EXIT (parse)", () => {
+    const cfg = cfgOf("src/flow.parse");
+    const exit = cfg.nodes.length - 1;
+    expect(cfg.edges.filter((e) => e.kind === "exception" && e.target === exit)).not.toHaveLength(0);
+  });
+
+  test("while (true) still emits the loop-exit false edge — the synthetic post-dominance edge (spin)", () => {
+    expect(kinds("src/flow.spin")).toContainEqual({ source: 2, target: 6, kind: "false" });
+    expect(kinds("src/flow.spin", (e) => e.kind === "break")).toHaveLength(1);
+  });
+
+  test("switch lowers to switch_case dispatch plus break edges (pickDay)", () => {
+    expect(kinds("src/flow.pickDay", (e) => e.kind === "switch_case")).toHaveLength(3);
+    expect(kinds("src/flow.pickDay", (e) => e.kind === "break")).toHaveLength(2);
+  });
+
+  test("await suspends via an await_resume edge (fetchTotal)", () => {
+    expect(kinds("src/susp.fetchTotal")).toContainEqual({ source: 2, target: 3, kind: "await_resume" });
+  });
+
+  test("yield suspends via a yield edge (numbers)", () => {
+    expect(kinds("src/susp.numbers")).toContainEqual({ source: 4, target: 5, kind: "yield" });
+  });
+
+  test("short-circuit / optional chaining stay intra-statement (shortCircuit has no branch edges)", () => {
+    expect(kinds("src/susp.shortCircuit", (e) => e.kind === "true" || e.kind === "false")).toHaveLength(0);
+  });
+});
+
+// ------------------------------------------------------------------------------------------------
+// Dominance gate (control dependence, hand-computed)
+// ------------------------------------------------------------------------------------------------
+
+describe("dominance gate", () => {
+  test("classify: exact hand-computed control dependences", () => {
+    expect(cdgSet("src/flow.classify")).toEqual(["0>1", "0>2", "0>3", "0>6", "3>4", "3>5"]);
+  });
+
+  test("early (early return): everything after the guard depends on it", () => {
+    expect(cdgSet("src/flow.early")).toEqual(["0>1", "0>2", "2>3", "2>4", "2>5"]);
+  });
+});
+
+// ------------------------------------------------------------------------------------------------
+// DFG gate
+// ------------------------------------------------------------------------------------------------
+
+describe("DFG gate", () => {
+  test("loop-carried dependency: acc feeds itself around the back edge (sumTo)", () => {
+    expect(ddgHas("src/flow.sumTo", 4, 4, "acc")).toBe(true);
+    expect(ddgHas("src/flow.sumTo", 3, 3, "i")).toBe(true);
+  });
+
+  test("shadowed variables do not leak edges across scopes (shadow)", () => {
+    // outer x (node 1) → return (node 4); inner x (node 2) → touch(x) (node 3); never 2 → 4.
+    expect(ddgHas("src/flow.shadow", 1, 4, "x")).toBe(true);
+    expect(ddgHas("src/flow.shadow", 2, 3, "x")).toBe(true);
+    expect(ddgHas("src/flow.shadow", 2, 4, "x")).toBe(false);
+  });
+
+  test("copy aliasing: a write through q reaches the read through p (useAlias)", () => {
+    expect(ddgHas("src/closures.useAlias", 3, 4, "p.f")).toBe(true);
+  });
+
+  test("closure capture: the captured local flows into the declaring statement (makeCounter)", () => {
+    expect(ddgHas("src/closures.makeCounter", 2, 3, "count")).toBe(true);
+  });
+
+  test("the closure body has its own graph, with the captured base defined at ENTRY", () => {
+    const inc = pdgOf("src/closures.makeCounter.inc");
+    expect(inc.some((e) => e.type === "DDG" && e.var === "count")).toBe(true);
+  });
+});
+
+// ------------------------------------------------------------------------------------------------
+// PDG gate — the intraprocedural backward slice, exact
+// ------------------------------------------------------------------------------------------------
+
+describe("PDG slice gate", () => {
+  test("backward slice of classify's return equals the hand-computed node set", () => {
+    // Node 2 (`let label = "none"`) is strongly killed on BOTH branches, so it is NOT in the slice.
+    const slice = backwardSlice(pg, { signature: "src/flow.classify", node: 6 });
+    const inClassify = [...slice].filter((k) => k.startsWith("src/flow.classify#")).sort();
+    expect(inClassify).toEqual([
+      "src/flow.classify#0",
+      "src/flow.classify#1",
+      "src/flow.classify#3",
+      "src/flow.classify#4",
+      "src/flow.classify#5",
+      "src/flow.classify#6",
+    ]);
+    expect([...slice].every((k) => k.startsWith("src/flow.classify#"))).toBe(true); // no callers → intra only
+  });
+});
+
+// ------------------------------------------------------------------------------------------------
+// Summary + SDG gates
+// ------------------------------------------------------------------------------------------------
+
+describe("summary and SDG gates", () => {
+  test("no dangling (signature, node_id) endpoints anywhere in the SDG", () => {
+    const valid = new Map<string, number>();
+    for (const [sig, g] of Object.entries(pg.functions)) valid.set(sig, (g.cfg as FunctionCfg).nodes.length);
+    for (const e of pg.sdg_edges) {
+      for (const end of [e.source, e.target]) {
+        const n = valid.get(end.signature);
+        expect(n, `dangling signature ${end.signature}`).toBeDefined();
+        expect(end.node, `dangling node ${end.signature}#${end.node}`).toBeLessThan(n as number);
+        expect(end.node).toBeGreaterThanOrEqual(0);
+      }
+    }
+  });
+
+  test("CALL edges target the callee ENTRY; positional PARAM_IN edges target `param` nodes", () => {
+    for (const e of pg.sdg_edges) {
+      if (e.type === "CALL") expect(e.target.node).toBe(0);
+      if (e.type === "PARAM_IN" && e.var?.startsWith("arg")) {
+        const callee = pg.functions[e.target.signature]?.cfg as FunctionCfg;
+        expect(callee.nodes[e.target.node]?.kind, `${e.target.signature}#${e.target.node}`).toBe("param");
+      }
+    }
+  });
+
+  test("PARAM_IN arity: argN edges never exceed the callee's declared parameters", () => {
+    for (const e of pg.sdg_edges) {
+      if (e.type !== "PARAM_IN" || !e.var?.startsWith("arg")) continue;
+      const callee = pg.functions[e.target.signature]?.cfg as FunctionCfg;
+      const params = callee.nodes.filter((n) => n.kind === "param").length;
+      expect(params, `${e.target.signature} has no params but receives ${e.var}`).toBeGreaterThan(0);
+    }
+  });
+
+  test("the a → b → c chain: CALL / PARAM_IN / PARAM_OUT stitched at each hop", () => {
+    expect(pg.sdg_edges).toContainEqual({
+      source: { signature: "src/chain.a", node: 2 },
+      target: { signature: "src/chain.b", node: 0 },
+      type: "CALL",
+    });
+    expect(pg.sdg_edges).toContainEqual({
+      source: { signature: "src/chain.a", node: 2 },
+      target: { signature: "src/chain.b", node: 1 },
+      type: "PARAM_IN",
+      var: "arg0",
+    });
+    expect(pg.sdg_edges).toContainEqual({
+      source: { signature: "src/chain.b", node: 4 },
+      target: { signature: "src/chain.a", node: 2 },
+      type: "PARAM_OUT",
+      var: "return",
+    });
+  });
+
+  test("SUMMARY gate: the composed transitive flow arg0 → return exists at a's callsite", () => {
+    expect(pg.sdg_edges).toContainEqual({
+      source: { signature: "src/chain.a", node: 2 },
+      target: { signature: "src/chain.a", node: 2 },
+      type: "SUMMARY",
+      var: "arg0",
+    });
+  });
+
+  test("cross-module (multi-file) SDG edges exist (viaOtherFile → util.increment)", () => {
+    expect(pg.sdg_edges).toContainEqual({
+      source: { signature: "src/chain.viaOtherFile", node: 2 },
+      target: { signature: "src/util.increment", node: 1 },
+      type: "PARAM_IN",
+      var: "arg0",
+    });
+  });
+
+  test("globals ride the SDG: transitive write and read of src/state.counter at churn's callsites", () => {
+    expect(
+      sdg(
+        (e) =>
+          e.type === "PARAM_OUT" &&
+          e.var === "src/state.counter" &&
+          e.source.signature === "src/state.bump" &&
+          e.target.signature === "src/state.churn",
+      ),
+    ).toHaveLength(1);
+    expect(
+      sdg(
+        (e) =>
+          e.type === "PARAM_IN" &&
+          e.var === "src/state.counter" &&
+          e.source.signature === "src/state.churn" &&
+          e.target.signature === "src/state.readCounter" &&
+          e.target.node === 0,
+      ),
+    ).toHaveLength(1);
+  });
+
+  test("a global written by one callee then read by the next shows up as caller-local DDG (main)", () => {
+    // bump(3) (node 1) transitively writes counter; a(readCounter()) (node 2) transitively reads it.
+    expect(ddgHas("src/main.main", 1, 2, "src/state.counter")).toBe(true);
+  });
+
+  test("mutual recursion (isEven/isOdd) reaches a fixpoint and stitches both directions", () => {
+    expect(sdg((e) => e.type === "CALL" && e.source.signature === "src/chain.isEven")).toHaveLength(1);
+    expect(sdg((e) => e.type === "CALL" && e.source.signature === "src/chain.isOdd")).toHaveLength(1);
+  });
+
+  test("interprocedural backward slice of main's return: exact, context-sensitive", () => {
+    const slice = backwardSlice(pg, { signature: "src/main.main", node: 3 });
+    const bySig = new Map<string, number[]>();
+    for (const k of slice) {
+      const [sig, n] = k.split("#") as [string, string];
+      bySig.set(sig, [...(bySig.get(sig) ?? []), Number(n)].sort((a, b) => a - b));
+    }
+    expect([...bySig.keys()].sort()).toEqual([
+      "src/chain.a",
+      "src/chain.b",
+      "src/chain.c",
+      "src/main.main",
+      "src/state.bump",
+      "src/state.readCounter",
+    ]);
+    expect(bySig.get("src/main.main")).toEqual([0, 1, 2, 3]);
+    expect(bySig.get("src/chain.a")).toEqual([0, 1, 2, 3, 4]);
+    expect(bySig.get("src/chain.c")).toEqual([0, 1, 2, 3]);
+    expect(bySig.get("src/state.bump")).toEqual([0, 1, 2, 3]);
+  });
+});
+
+// ------------------------------------------------------------------------------------------------
+// Determinism + level gating
+// ------------------------------------------------------------------------------------------------
+
+describe("determinism and gating", () => {
+  test("two runs on identical content emit byte-identical program_graphs", () => {
+    const second = run(3);
+    expect(JSON.stringify(second.program_graphs)).toBe(JSON.stringify(pg));
+  });
+
+  test("-a 1 emits no program_graphs section", () => {
+    const level1 = run(1);
+    expect(level1.program_graphs).toBeUndefined();
+    expect(JSON.stringify(level1)).not.toContain("program_graphs");
+  });
+
+  test("schema_version and k_limit are stamped", () => {
+    expect(pg.schema_version).toBe("1.0.0");
+    expect(pg.k_limit).toBe(3);
+  });
+});
+
+// ------------------------------------------------------------------------------------------------
+// CLI flag validation (strict, non-zero exit — cli-contract.md)
+// ------------------------------------------------------------------------------------------------
+
+describe("--graphs flag validation", () => {
+  const cli = (...args: string[]) =>
+    Bun.spawnSync(["bun", "run", path.resolve(import.meta.dir, "../src/index.ts"), ...args], {
+      cwd: path.resolve(import.meta.dir, ".."),
+    });
+
+  test("unknown --graphs value fails with a clear error, never a silent fallback", () => {
+    const r = cli("-i", FIXTURE, "-a", "3", "--graphs", "cfg,bogus", "--no-build");
+    expect(r.exitCode).not.toBe(0);
+    expect(r.stderr.toString()).toContain("unknown --graphs value 'bogus'");
+  });
+
+  test("--graphs without -a 3 is rejected", () => {
+    const r = cli("-i", FIXTURE, "--graphs", "cfg", "--no-build");
+    expect(r.exitCode).not.toBe(0);
+    expect(r.stderr.toString()).toContain("--graphs requires --analysis-level 3");
+  });
+
+  test("--graph-field-depth must be a positive integer", () => {
+    const r = cli("-i", FIXTURE, "-a", "3", "--graph-field-depth", "zero", "--no-build");
+    expect(r.exitCode).not.toBe(0);
+    expect(r.stderr.toString()).toContain("invalid --graph-field-depth");
+  });
+});
diff --git a/test/fixtures/dataflow-app/package.json b/test/fixtures/dataflow-app/package.json
new file mode 100644
index 0000000..0d9095b
--- /dev/null
+++ b/test/fixtures/dataflow-app/package.json
@@ -0,0 +1,6 @@
+{
+  "name": "dataflow-app",
+  "version": "0.0.0",
+  "private": true,
+  "description": "Level-3 dataflow fixture: exercises every stage-1 lowering construct and the shared fixture minimums (dataflow-construction.md)."
+}
diff --git a/test/fixtures/dataflow-app/src/chain.ts b/test/fixtures/dataflow-app/src/chain.ts
new file mode 100644
index 0000000..9dac5dc
--- /dev/null
+++ b/test/fixtures/dataflow-app/src/chain.ts
@@ -0,0 +1,30 @@
+/** Interprocedural chains: a → b → c value flow, cross-file flow, mutual recursion. */
+import { increment } from "./util";
+
+export function c(z: number): number {
+  return z + 1; // the parameter flows to the return value
+}
+
+export function b(y: number): number {
+  const fromC = c(y);
+  return fromC;
+}
+
+export function a(x: number): number {
+  const fromB = b(x); // SUMMARY edge here: arg0 flows through b (and c) to the result
+  return fromB;
+}
+
+export function viaOtherFile(x: number): number {
+  return increment(x); // cross-module CALL / PARAM_IN / PARAM_OUT edges
+}
+
+export function isEven(n: number): boolean {
+  if (n === 0) return true;
+  return isOdd(n - 1); // mutual recursion: {isEven, isOdd} form an SCC
+}
+
+export function isOdd(n: number): boolean {
+  if (n === 0) return false;
+  return isEven(n - 1);
+}
diff --git a/test/fixtures/dataflow-app/src/closures.ts b/test/fixtures/dataflow-app/src/closures.ts
new file mode 100644
index 0000000..522839d
--- /dev/null
+++ b/test/fixtures/dataflow-app/src/closures.ts
@@ -0,0 +1,17 @@
+/** Closure capture and copy aliasing. */
+
+export function makeCounter(start: number): () => number {
+  let count = start;
+  const inc = (): number => {
+    count = count + 1; // writes the captured local
+    return count;
+  };
+  return inc;
+}
+
+export function useAlias(): number {
+  const p = { f: 1 };
+  const q = p; // q and p alias the same object
+  q.f = 42; // write through q ...
+  return p.f; // ... must reach this read through p
+}
diff --git a/test/fixtures/dataflow-app/src/flow.ts b/test/fixtures/dataflow-app/src/flow.ts
new file mode 100644
index 0000000..b57b19b
--- /dev/null
+++ b/test/fixtures/dataflow-app/src/flow.ts
@@ -0,0 +1,86 @@
+/** Intraprocedural constructs: branches, loops, early return, exceptions, switch, shadowing. */
+
+export function classify(n: number): string {
+  let label = "none";
+  if (n > 0) {
+    label = "pos";
+  } else {
+    label = "neg";
+  }
+  return label;
+}
+
+export function sumTo(n: number): number {
+  let acc = 0;
+  for (let i = 0; i < n; i++) {
+    acc = acc + i; // loop-carried dependency: acc feeds itself around the back edge
+  }
+  return acc;
+}
+
+export function early(n: number): number {
+  if (n < 0) {
+    return -1; // early return (multi-exit normalization)
+  }
+  const r = n * 2;
+  return r;
+}
+
+export function parse(s: string): number {
+  const v = Number(s);
+  if (Number.isNaN(v)) {
+    throw new Error(`bad input: ${s}`);
+  }
+  return v;
+}
+
+export function guarded(s: string): number {
+  let out = 0;
+  try {
+    out = parse(s); // may throw → exception edge into the catch node
+  } catch (e) {
+    out = -1;
+  } finally {
+    touch(out);
+  }
+  return out;
+}
+
+export function touch(x: number): void {
+  void x;
+}
+
+export function pickDay(d: number): string {
+  let name = "";
+  switch (d) {
+    case 0:
+      name = "sun";
+      break;
+    case 6:
+      name = "sat";
+      break;
+    default:
+      name = "weekday";
+  }
+  return name;
+}
+
+export function spin(): number {
+  let ticks = 0;
+  while (true) {
+    ticks = ticks + 1; // infinite loop: the dead loop-exit edge keeps EXIT reachable
+    if (ticks > 3) {
+      break;
+    }
+  }
+  return ticks;
+}
+
+export function shadow(): number {
+  const x = 1;
+  {
+    const x = 2; // shadows the outer x — must NOT leak DDG edges across scopes
+    touch(x);
+  }
+  return x;
+}
diff --git a/test/fixtures/dataflow-app/src/main.ts b/test/fixtures/dataflow-app/src/main.ts
new file mode 100644
index 0000000..f37b2da
--- /dev/null
+++ b/test/fixtures/dataflow-app/src/main.ts
@@ -0,0 +1,9 @@
+/** Multi-file flow: state and chain wired together (cross-module SDG edges). */
+import { a } from "./chain";
+import { bump, readCounter } from "./state";
+
+export function main(): number {
+  bump(3);
+  const r = a(readCounter());
+  return r;
+}
diff --git a/test/fixtures/dataflow-app/src/state.ts b/test/fixtures/dataflow-app/src/state.ts
new file mode 100644
index 0000000..d6dc769
--- /dev/null
+++ b/test/fixtures/dataflow-app/src/state.ts
@@ -0,0 +1,16 @@
+/** Module-level global state: written in one function, read in another. */
+
+export let counter = 0;
+
+export function bump(by: number): void {
+  counter = counter + by; // global write
+}
+
+export function readCounter(): number {
+  return counter; // global read that flows to the return value
+}
+
+export function churn(by: number): number {
+  bump(by); // transitive global write lands on this callsite node
+  return readCounter(); // transitive global read
+}
diff --git a/test/fixtures/dataflow-app/src/susp.ts b/test/fixtures/dataflow-app/src/susp.ts
new file mode 100644
index 0000000..fcafd7e
--- /dev/null
+++ b/test/fixtures/dataflow-app/src/susp.ts
@@ -0,0 +1,25 @@
+/** Suspension points (await/yield) and intra-statement expression control flow. */
+
+export async function compute(x: number): Promise<number> {
+  return x * 2;
+}
+
+export async function fetchTotal(x: number): Promise<number> {
+  const a = await compute(x); // await_resume edge out of this statement
+  return a + 1;
+}
+
+export function* numbers(n: number): Generator<number, number, unknown> {
+  let i = 0;
+  while (i < n) {
+    yield i; // yield (suspend/resume) edge
+    i = i + 1;
+  }
+  return n;
+}
+
+export function shortCircuit(a: { f?: number } | null, b: number): number {
+  const v = (a && a.f) || b; // short-circuit stays intra-statement (documented rule)
+  const w = a?.f ?? b; // optional chaining likewise
+  return v + w;
+}
diff --git a/test/fixtures/dataflow-app/src/taint.ts b/test/fixtures/dataflow-app/src/taint.ts
new file mode 100644
index 0000000..0e71659
--- /dev/null
+++ b/test/fixtures/dataflow-app/src/taint.ts
@@ -0,0 +1,26 @@
+/**
+ * Source → sink pair (one raw, one sanitized). The taint client is a staged follow-up
+ * (issue #2 PR E); the fixture carries the flows now so that PR only adds the query.
+ */
+
+export function source(): string {
+  return "user-input";
+}
+
+export function sanitize(s: string): string {
+  return s.replace(/dangerous/g, "");
+}
+
+export function sink(s: string): void {
+  void s;
+}
+
+export function unsafeFlow(): void {
+  const s = source();
+  sink(s);
+}
+
+export function safeFlow(): void {
+  const s = sanitize(source());
+  sink(s);
+}
diff --git a/test/fixtures/dataflow-app/src/util.ts b/test/fixtures/dataflow-app/src/util.ts
new file mode 100644
index 0000000..27ec861
--- /dev/null
+++ b/test/fixtures/dataflow-app/src/util.ts
@@ -0,0 +1,3 @@
+export function increment(v: number): number {
+  return v + 1;
+}
diff --git a/test/fixtures/dataflow-app/tsconfig.json b/test/fixtures/dataflow-app/tsconfig.json
new file mode 100644
index 0000000..f0b0c56
--- /dev/null
+++ b/test/fixtures/dataflow-app/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": false,
+    "noEmit": true
+  },
+  "include": ["src"]
+}
diff --git a/test/neo4j-bolt.test.ts b/test/neo4j-bolt.test.ts
index 65c8eca..c3600c7 100644
--- a/test/neo4j-bolt.test.ts
+++ b/test/neo4j-bolt.test.ts
@@ -37,6 +37,8 @@ function optsFor(overrides: Partial<AnalysisOptions> = {}): AnalysisOptions {
     neo4jPassword: "",
     neo4jDatabase: null,
     analysisLevel: 1,
+    graphs: ["cfg", "dfg", "pdg", "sdg"],
+    graphFieldDepth: 3,
     targetFiles: null,
     skipTests: true,
     eager: true,
diff --git a/test/neo4j-schema.test.ts b/test/neo4j-schema.test.ts
index 8f56659..80613a8 100644
--- a/test/neo4j-schema.test.ts
+++ b/test/neo4j-schema.test.ts
@@ -28,7 +28,7 @@ function fixtureRows() {
   const opts: AnalysisOptions = {
     input: FIXTURE, output: null, emit: "json", appName: "sample-app",
     neo4jUri: null, neo4jUser: "neo4j", neo4jPassword: "", neo4jDatabase: null,
-    analysisLevel: 1, targetFiles: null, skipTests: true, eager: true,
+    analysisLevel: 1, graphs: ["cfg", "dfg", "pdg", "sdg"], graphFieldDepth: 3, targetFiles: null, skipTests: true, eager: true,
     noBuild: true, phantoms: true, callGraphProvider: "tsc", cacheDir, verbosity: 0,
   };
   try {

From a52f01cb6177a458afd937c505f427f1a83017b7 Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Wed, 1 Jul 2026 22:18:54 -0400
Subject: [PATCH 06/32] feat: parallel execution model for level-3 graphs
 (-j/--jobs)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Implements the contract's parallel model on top of the sequential oracle:

- Stage split: fact extraction (AST-bound, once per callable) is hoisted
  out of the summary fixpoint; the reaching-defs solve (defuse.solveDefUse)
  is now pure data and re-runs without touching the AST. CallableGraphData
  is the serializable per-callable projection that crosses the worker
  boundary.
- Stages 1-4 (CFG, dominance, def-use facts, PDG) fan out per callable
  over a Bun worker pool, partitioned by file; each worker materializes
  its own whole-program ts-morph project (ASTs cannot be structured-cloned)
  and returns plain data.
- The call-graph solve overlaps extraction: at -a 3, core.ts posts the
  extraction to the pool BEFORE the provider (tsc resolver + Jelly
  subprocess) runs on the main thread, and joins before summaries.
- Stages 6-7 run as a Kahn-style ready-queue wavefront over the Tarjan SCC
  condensation DAG (per-SCC dependency counters; the SCC and its internal
  fixpoint are the atomic unit, one worker each).
- Determinism: --jobs N output is byte-identical to --jobs 1 (span-ordered
  ids, collect-then-sort emission, sccFixpoint pure), enforced by a
  differential test. --jobs 1 is the sequential debug mode.
- Failure discipline: a dying worker is retired and its queue never
  strands (a stranded queue previously let the process exit 0 without
  emitting output); extraction failure closes the pool so the wavefront
  degrades sequentially too — a warning, never wrong or missing output.
- Compiled binary: the worker is a second bun build --compile entrypoint,
  embedded as /$bunfs/root/dataflow/worker.js; pool resolves the URL per
  runtime. Verified: dist/cants -a 3 -j 2 runs workers with byte-identical
  output.
- Default is sequential: measurement (self-analysis: 36 files, 211
  callables) shows per-worker project load dominates the parallelizable
  graph math at small/mid scale (2.5x slower at -j 14), so -j N is an
  explicit opt-in for large codebases.

Also fixes a latent bug: TSCallable.path is absolute, so the summary
cache's symbol_table[c.path] content-hash lookup always missed; now keyed
by the project-relative file key.
---
 README.md                             |  16 +
 package.json                          |   2 +-
 src/cli.ts                            |  16 +
 src/core.ts                           |  17 +-
 src/dataflow/defuse.ts                | 246 ++++++--------
 src/dataflow/extract.ts               |  91 +++++
 src/dataflow/index.ts                 | 466 ++++++++++++++++++--------
 src/dataflow/model.ts                 | 123 ++++++-
 src/dataflow/pool.ts                  | 104 ++++++
 src/dataflow/sdg.ts                   |  22 +-
 src/dataflow/summaries.ts             | 156 +++++----
 src/dataflow/worker.ts                |  96 ++++++
 src/index.ts                          |   2 +-
 src/options/options.ts                |   8 +
 src/syntactic_analysis/symbolTable.ts |   3 +-
 test/dataflow.test.ts                 |  28 +-
 test/neo4j-bolt.test.ts               |   7 +-
 test/neo4j-schema.test.ts             |  10 +-
 tsconfig.json                         |   2 +-
 19 files changed, 1003 insertions(+), 412 deletions(-)
 create mode 100644 src/dataflow/extract.ts
 create mode 100644 src/dataflow/pool.ts
 create mode 100644 src/dataflow/worker.ts

diff --git a/README.md b/README.md
index 586cf0e..62918f0 100644
--- a/README.md
+++ b/README.md
@@ -165,6 +165,10 @@ Options:
                                  (default: all; requires -a 3)
   --graph-field-depth <k>        access-path depth bound (k-limit) for level-3
                                  dataflow (default: "3")
+  -j, --jobs <n>                 worker parallelism for level-3 graphs (default:
+                                 sequential; opt in with N ≥ 2 on large projects
+                                 — each worker loads its own copy of the
+                                 program)
   -t, --target-files <paths...>  restrict analysis to specific files
                                  (incremental)
   --skip-tests                   skip test trees (default)
@@ -281,6 +285,18 @@ over-approximate; known unsoundness (dynamic `eval`, reflection/monkey-patching,
 effects) is recorded in `.claude/SCHEMA_DECISIONS.md`. Backward slicing and taint run as queries
 over the SDG (slicing ships now inside the analyzer; the configurable taint pack is staged).
 
+**Parallelism (`-j/--jobs`).** The pipeline implements the level-3 parallel execution model:
+stage-1–4 extraction fans out per callable over a Bun worker pool (partitioned by file) and is
+posted *before* the call-graph solve so the two overlap; summary composition runs as a
+Kahn-style ready-queue wavefront over the SCC condensation DAG (the SCC is the atomic unit).
+`--jobs N` output is **byte-identical** to `--jobs 1` (node ids are span-ordered, all edge lists
+are collect-then-sorted, and the SCC fixpoint is a pure function of its inputs) — enforced by a
+differential test. It is off by default and worth opting into only on large codebases: ts-morph
+ASTs cannot cross the worker boundary, so each extraction worker loads its own copy of the
+program, which dominates the parallelizable graph math on small/mid repos (self-analysis runs
+2.5× slower at `-j 14`). Worker failure at any stage degrades to the sequential path with a
+warning — never to wrong or missing output.
+
 Levels 1/2 are unaffected: nothing in level 3 runs unless `-a 3` is requested.
 
 ### Neo4j graph
diff --git a/package.json b/package.json
index 6c13526..3fee9cb 100644
--- a/package.json
+++ b/package.json
@@ -9,7 +9,7 @@
   },
   "scripts": {
     "start": "bun run src/index.ts",
-    "build": "bun build ./src/main.ts --compile --external @babel/preset-typescript --outfile dist/cants",
+    "build": "bun build ./src/main.ts ./src/dataflow/worker.ts --compile --external @babel/preset-typescript --outfile dist/cants",
     "gen:schema": "bun run src/index.ts --emit schema > schema.neo4j.json",
     "gen:readme": "bun run scripts/update-readme.ts",
     "test:container": "RUN_CONTAINER_TESTS=1 bun test test/neo4j-bolt.test.ts",
diff --git a/src/cli.ts b/src/cli.ts
index 4df7fe3..261049f 100644
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -46,6 +46,10 @@ export function buildProgram(): Command {
       "level-3 graph sections to emit, comma-separated: cfg | dfg | pdg | sdg (default: all; requires -a 3)",
     )
     .option("--graph-field-depth <k>", "access-path depth bound (k-limit) for level-3 dataflow", "3")
+    .option(
+      "-j, --jobs <n>",
+      "worker parallelism for level-3 graphs (default: sequential; opt in with N ≥ 2 on large projects — each worker loads its own copy of the program)",
+    )
     .option("-t, --target-files <paths...>", "restrict analysis to specific files (incremental)")
     .option("--skip-tests", "skip test trees (default)")
     .option("--include-tests", "include test trees")
@@ -99,6 +103,17 @@ export function parseArgs(argv: string[]): AnalysisOptions {
   if (!Number.isInteger(k) || k < 1) {
     program.error(`error: invalid --graph-field-depth '${kStr}' (expected a positive integer)`);
   }
+
+  // -j/--jobs: explicit value must be a positive integer; omitted ⇒ 0 = auto, resolved against
+  // the project size at extraction time (see startExtraction).
+  let jobs = 0;
+  if (o.jobs !== undefined) {
+    const j = Number(String(o.jobs));
+    if (!Number.isInteger(j) || j < 1) {
+      program.error(`error: invalid --jobs '${String(o.jobs)}' (expected a positive integer)`);
+    }
+    jobs = j;
+  }
   const emit: EmitTarget = o.emit === "neo4j" ? "neo4j" : o.emit === "schema" ? "schema" : "json";
   // --emit schema is a static artifact and needs no project; every other target requires -i.
   if (emit !== "schema" && !o.input) program.error("required option '-i, --input <path>' not specified");
@@ -133,6 +148,7 @@ export function parseArgs(argv: string[]): AnalysisOptions {
     analysisLevel: level,
     graphs,
     graphFieldDepth: k,
+    jobs,
     targetFiles: targets,
     skipTests: o.includeTests ? false : true,
     eager: Boolean(o.eager),
diff --git a/src/core.ts b/src/core.ts
index 372360f..f29861f 100644
--- a/src/core.ts
+++ b/src/core.ts
@@ -1,5 +1,5 @@
 import * as path from "node:path";
-import { buildProgramGraphs } from "./dataflow";
+import { buildProgramGraphs, startExtraction } from "./dataflow";
 import { selectProvider } from "./semantic_analysis";
 import { loadCache, saveCache } from "./utils";
 import { materialize } from "./build";
@@ -12,7 +12,7 @@ import { Logger } from "./utils";
  * The orchestrator. Order mirrors the reference analyzers: materialize deps → build the symbol
  * table → build the resolver call graph → cache the base → return the Application.
  */
-export function analyze(opts: AnalysisOptions): TSApplication {
+export async function analyze(opts: AnalysisOptions): Promise<TSApplication> {
   const log = new Logger(opts.verbosity);
   log.info(`analyzing ${opts.input} (level ${opts.analysisLevel})`);
   const cacheDir = opts.cacheDir ?? path.join(opts.input, ".codeanalyzer");
@@ -23,6 +23,11 @@ export function analyze(opts: AnalysisOptions): TSApplication {
   const cached = opts.eager ? null : loadCache(cacheDir);
   const { project, symbol_table } = buildSymbolTable(opts, mat, cached?.symbol_table ?? null, log);
 
+  // Level 3: post stage-1–4 graph extraction to the worker pool BEFORE the call-graph solve —
+  // extraction doesn't need callee resolution, so the two run concurrently (the contract's
+  // "points-to solve runs concurrently with stages 1–4") and join in buildProgramGraphs.
+  const extraction = opts.analysisLevel === 3 ? startExtraction(project, symbol_table, mat.tsConfigFilePath, opts, log) : null;
+
   // Call graph via the selected provider (union of tsc+jelly by default; --tsc-only / jelly opt-in).
   const provider = selectProvider(opts.callGraphProvider);
   log.info(`call graph provider: ${provider.name}`);
@@ -36,10 +41,10 @@ export function analyze(opts: AnalysisOptions): TSApplication {
     synthesized_callables: cg.synthesized_callables,
   };
 
-  // Level 3: native program graphs (CFG/PDG/SDG). Strictly flag-gated so -a 1/-a 2 cost nothing;
-  // runs after the call graph because the SDG consumes its backfilled callee signatures.
-  if (opts.analysisLevel === 3) {
-    app.program_graphs = buildProgramGraphs({ project, symbol_table, opts, log });
+  // Level 3 join: stages 5–7 (summary wavefront + SDG) consume the extraction AND the
+  // provider-backfilled callee signatures. Strictly flag-gated so -a 1/-a 2 cost nothing.
+  if (extraction) {
+    app.program_graphs = await buildProgramGraphs(extraction, symbol_table, opts, log);
   }
 
   saveCache(cacheDir, { symbol_table, call_graph });
diff --git a/src/dataflow/defuse.ts b/src/dataflow/defuse.ts
index 2b1bd6e..2fc4a84 100644
--- a/src/dataflow/defuse.ts
+++ b/src/dataflow/defuse.ts
@@ -1,5 +1,13 @@
 /**
- * Stage 3 — variable identity (k-limited access paths) and local def-use (the DDG).
+ * Stage 3 — variable identity (k-limited access paths) and local def-use (the DDG), split in two
+ * along the AST/data boundary:
+ *
+ *  - `extractFunctionFacts` (AST-bound, ONCE per callable): walks the ts-morph AST and records
+ *    each node's defs/uses, the copy-alias pairs, and the return-value nodes. This is the only
+ *    half that touches the AST, so it can run inside extraction workers.
+ *  - `solveDefUse` (pure data, re-run freely): reaching definitions over the serialized CFG with
+ *    callee global effects overlaid at callsite nodes → labeled DDG edges. The summary fixpoint
+ *    (stage 6) re-runs ONLY this half per iteration — never re-extraction.
  *
  * Access-path model: `base(.field | [*])*`, where the base is a local, parameter, `this`,
  * captured variable, or module binding — identified by its *declaration node* (so shadowed names
@@ -12,103 +20,72 @@
  * bases connected by direct copies (`const q = p`); a write through one name weakly updates the
  * other. Points-to-backed aliasing via Jelly's solved state is the staged upgrade (PR F).
  *
- * Def-use: classic forward may reaching-definitions over the stage-1 CFG. Strong (killing)
- * defs are whole-base writes to locals/params; every field write is weak. Captured/module/this
- * bases get a synthetic def at ENTRY (their value on function entry) — the same convention the
- * SDG uses when it targets ENTRY with global PARAM_IN edges. Reads inside nested callables of
- * variables they capture are attributed to the declaring statement node (capture-at-declaration).
- *
- * Call-site global effects (`callEffects`): the summary driver (stage 6) re-runs this analysis
- * with the transitive global reads/writes of each call's callee applied at the callsite node,
- * which is how cross-function global flow becomes visible in the caller's DDG.
+ * Def-use: classic forward may reaching-definitions. Strong (killing) defs are whole-base writes
+ * to locals/params; every field write is weak. Captured/module/this bases get a synthetic def at
+ * ENTRY (their value on function entry) — the same convention the SDG uses when it targets ENTRY
+ * with global PARAM_IN edges. Reads inside nested callables of variables they capture are
+ * attributed to the declaring statement node (capture-at-declaration). EXIT doubles as the HRB
+ * formal-out node: return-value nodes and module-global writes get synthetic DDG edges into EXIT.
  */
 import { Node, SyntaxKind } from "ts-morph";
 import type { PdgEdge } from "../schema";
 import { fileKeyOf } from "../schema";
 import { isFunctionBoundary } from "./cfg";
-import { adjacency, type DfNode, type FunctionCfgBuild } from "./model";
+import {
+  dataAdjacency,
+  renderPath,
+  fieldsMayAlias,
+  type BaseKind,
+  type CallEffects,
+  type CallableGraphData,
+  type DefFact,
+  type DfNode,
+  type FunctionCfgBuild,
+  type NodeFacts,
+  type PathRef,
+} from "./model";
 
 // ------------------------------------------------------------------------------------------------
-// Access paths
+// Extraction (AST-bound, once per callable)
 // ------------------------------------------------------------------------------------------------
 
-export type BaseKind = "local" | "param" | "this" | "captured" | "module";
-
-export interface PathRef {
-  /** Unique base identity: decl-position for locals/params/captured, canonical path for module, "this". */
-  key: string;
-  /** Human label for the base (the variable name / canonical module path). */
-  label: string;
-  baseKind: BaseKind;
-  fields: string[]; // "f" | "[*]" | "*" (trailing truncation star)
+export interface FunctionFacts {
+  facts: Array<[number, NodeFacts]>;
+  aliasPairs: Array<[string, string]>;
+  returnValueNodes: number[];
 }
 
-export function renderPath(p: PathRef): string {
-  let s = p.label;
-  for (const f of p.fields) s += f === "[*]" ? "[*]" : `.${f}`;
-  return s;
-}
+export function extractFunctionFacts(build: FunctionCfgBuild, root: string, k: number): FunctionFacts {
+  const aliasPairs: Array<[string, string]> = [];
+  const union = (a: string, b: string): void => {
+    aliasPairs.push([a, b]);
+  };
 
-/** A global (module-binding) path as carried by summaries: canonical base + fields. */
-export interface GlobalPath {
-  key: string; // == the canonical `<modulePrefix>.<name>` label
-  fields: string[];
-}
+  const facts: Array<[number, NodeFacts]> = [];
+  for (const n of build.nodes) {
+    if (n.kind === "entry" || n.kind === "exit") {
+      facts.push([n.id, { defs: [], uses: [] }]);
+      continue;
+    }
+    facts.push([n.id, extractFacts(n, build, root, k, union)]);
+  }
 
-export function renderGlobal(g: GlobalPath): string {
-  return renderPath({ key: g.key, label: g.key, baseKind: "module", fields: g.fields });
+  const returnValueNodes: number[] = [];
+  const body = getBody(build.fn);
+  const isExprBody = body !== undefined && !Node.isBlock(body);
+  for (const n of build.nodes) {
+    if (!n.ast) continue;
+    if (Node.isReturnStatement(n.ast) && n.ast.getExpression()) returnValueNodes.push(n.id);
+    else if (isExprBody && n.ast === body) returnValueNodes.push(n.id); // arrow expression body
+  }
+
+  return { facts, aliasPairs, returnValueNodes };
 }
 
 function kLimit(fields: string[], k: number): string[] {
   return fields.length > k ? [...fields.slice(0, k), "*"] : fields;
 }
 
-/** May two field lists overlap? "*" (truncation) matches any tail; "[*]" matches any one step. */
-function fieldsMayAlias(a: string[], b: string[]): boolean {
-  const n = Math.min(a.length, b.length);
-  for (let i = 0; i < n; i++) {
-    const x = a[i] as string;
-    const y = b[i] as string;
-    if (x === "*" || y === "*") return true;
-    if (x === "[*]" || y === "[*]") continue; // dynamic index may hit any member
-    if (x !== y) return false;
-  }
-  return true; // one path is a prefix of the other (whole-object vs member)
-}
-
-// ------------------------------------------------------------------------------------------------
-// Per-node dataflow facts
-// ------------------------------------------------------------------------------------------------
-
-export interface DefFact {
-  ref: PathRef;
-  /** Strong defs kill; only whole-base writes of locals/params qualify (field writes are weak). */
-  strong: boolean;
-}
-
-export interface NodeFacts {
-  defs: DefFact[];
-  uses: PathRef[];
-}
-
-export interface CallEffects {
-  reads: GlobalPath[];
-  writes: GlobalPath[];
-}
-
-export interface DefUseResult {
-  ddg: PdgEdge[];
-  facts: Map<number, NodeFacts>;
-  /** Union-find representative per base key (the copy-alias classes). */
-  aliasRep: Map<string, string>;
-  /** Nodes that produce the function's return value (`return expr` / arrow expression body). */
-  returnValueNodes: Set<number>;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Base resolution
-// ------------------------------------------------------------------------------------------------
-
 function enclosingCallable(node: Node): Node | undefined {
   let cur: Node | undefined = node.getParent();
   while (cur) {
@@ -162,10 +139,6 @@ function resolveBase(id: Node, fn: Node, root: string): PathRef | null {
   return { key: `cap:${decl.getStart()}`, label: name, baseKind: "captured", fields: [] };
 }
 
-// ------------------------------------------------------------------------------------------------
-// Expression walking (defs/uses extraction)
-// ------------------------------------------------------------------------------------------------
-
 class ExprWalker {
   defs: DefFact[] = [];
   uses: PathRef[] = [];
@@ -338,9 +311,7 @@ class ExprWalker {
         if (parent && Node.isPropertyAssignment(parent) && parent.getNameNode() === n) return;
         const b = resolveBase(n, this.fn, this.root);
         if (!b) return;
-        // Only reads that escape the nested callable count: a decl inside it resolves to
-        // local/param of the *outer* fn only when it isn't nested — resolveBase already keys by
-        // decl site, so filter decls physically inside the nested subtree.
+        // Only reads that escape the nested callable count: filter decls physically inside it.
         const decl = declOf(n);
         if (decl && decl.getStart() >= fnNode.getStart() && decl.getEnd() <= fnNode.getEnd()) return;
         this.uses.push(b);
@@ -380,10 +351,6 @@ function isAssignmentOperator(k: SyntaxKind): boolean {
   return k >= SyntaxKind.FirstAssignment && k <= SyntaxKind.LastAssignment;
 }
 
-// ------------------------------------------------------------------------------------------------
-// Per-node fact extraction
-// ------------------------------------------------------------------------------------------------
-
 function extractFacts(
   n: DfNode,
   build: FunctionCfgBuild,
@@ -457,42 +424,39 @@ function extractFacts(
   return { defs: w.defs, uses: w.uses };
 }
 
+function getBody(fn: Node): Node | undefined {
+  return (fn as unknown as { getBody?: () => Node | undefined }).getBody?.();
+}
+
 // ------------------------------------------------------------------------------------------------
-// Reaching definitions → DDG
+// Solve (pure data — safe to re-run every fixpoint iteration, on any thread)
 // ------------------------------------------------------------------------------------------------
 
-export function computeDefUse(
-  build: FunctionCfgBuild,
-  root: string,
-  k: number,
-  callEffects: Map<number, CallEffects>,
-): DefUseResult {
-  // --- union-find over base keys (copy aliases) ---
+export interface SolveResult {
+  ddg: PdgEdge[];
+  /** The facts with callee effects and ENTRY ambient defs overlaid (what summaries read). */
+  effective: Map<number, NodeFacts>;
+}
+
+export function solveDefUse(data: CallableGraphData, callEffects: Map<number, CallEffects>): SolveResult {
+  // --- union-find over base keys (copy aliases, replayed from extraction) ---
   const parent = new Map<string, string>();
   const find = (x: string): string => {
     let r = x;
     while (parent.has(r) && parent.get(r) !== r) r = parent.get(r) as string;
     return r;
   };
-  const union = (a: string, b: string): void => {
+  for (const [a, b] of data.aliasPairs) {
     const ra = find(a);
     const rb = find(b);
     if (ra !== rb) parent.set(ra, rb);
-  };
-
-  // --- facts per node ---
-  const facts = new Map<number, NodeFacts>();
-  for (const n of build.nodes) {
-    if (n.kind === "entry" || n.kind === "exit") {
-      facts.set(n.id, { defs: [], uses: [] });
-      continue;
-    }
-    facts.set(n.id, extractFacts(n, build, root, k, union));
   }
 
-  // --- apply callee global effects at callsite nodes ---
+  // --- overlay: base facts + callee global effects at callsite nodes (never mutate the base) ---
+  const effective = new Map<number, NodeFacts>();
+  for (const [id, f] of data.facts) effective.set(id, { defs: [...f.defs], uses: [...f.uses] });
   for (const [nodeId, eff] of callEffects) {
-    const f = facts.get(nodeId);
+    const f = effective.get(nodeId);
     if (!f) continue;
     for (const g of eff.reads) f.uses.push({ key: g.key, label: g.key, baseKind: "module", fields: g.fields });
     for (const g of eff.writes)
@@ -500,9 +464,9 @@ export function computeDefUse(
   }
 
   // --- ENTRY defs for ambient bases (module / captured / this): their value on entry ---
-  const entryFacts = facts.get(build.entryId) as NodeFacts;
+  const entryFacts = effective.get(data.entryId) as NodeFacts;
   const ambient = new Map<string, PathRef>();
-  for (const f of facts.values()) {
+  for (const f of effective.values()) {
     for (const u of f.uses) if (u.baseKind !== "local" && u.baseKind !== "param") ambient.set(u.key, u);
     for (const d of f.defs) if (d.ref.baseKind !== "local" && d.ref.baseKind !== "param") ambient.set(d.ref.key, d.ref);
   }
@@ -518,18 +482,18 @@ export function computeDefUse(
   }
   const universe: DefEntry[] = [];
   const genOf = new Map<number, Set<number>>();
-  for (const n of build.nodes) {
+  for (const n of data.nodes) {
     const gen = new Set<number>();
-    for (const d of facts.get(n.id)?.defs ?? []) {
+    for (const d of effective.get(n.id)?.defs ?? []) {
       gen.add(universe.length);
       universe.push({ node: n.id, ref: d.ref, strong: d.strong });
     }
     genOf.set(n.id, gen);
   }
   const killOf = new Map<number, Set<number>>();
-  for (const n of build.nodes) {
+  for (const n of data.nodes) {
     const kill = new Set<number>();
-    for (const d of facts.get(n.id)?.defs ?? []) {
+    for (const d of effective.get(n.id)?.defs ?? []) {
       if (!d.strong) continue;
       for (const [i, u] of universe.entries()) {
         if (u.node !== n.id && find(u.ref.key) === find(d.ref.key)) kill.add(i);
@@ -539,14 +503,14 @@ export function computeDefUse(
   }
 
   // --- worklist ---
-  const { succ, pred } = adjacency(build);
+  const { succ, pred } = dataAdjacency(data);
   const inOf = new Map<number, Set<number>>();
   const outOf = new Map<number, Set<number>>();
-  for (const n of build.nodes) {
+  for (const n of data.nodes) {
     inOf.set(n.id, new Set());
     outOf.set(n.id, new Set());
   }
-  const work: number[] = build.nodes.map((n) => n.id);
+  const work: number[] = data.nodes.map((n) => n.id);
   while (work.length) {
     const id = work.shift() as number;
     const inSet = new Set<number>();
@@ -567,8 +531,8 @@ export function computeDefUse(
     find(a.key) === find(b.key) && fieldsMayAlias(a.fields, b.fields);
   const ddg: PdgEdge[] = [];
   const seen = new Set<string>();
-  for (const n of build.nodes) {
-    const f = facts.get(n.id) as NodeFacts;
+  for (const n of data.nodes) {
+    const f = effective.get(n.id) as NodeFacts;
     if (!f.uses.length) continue;
     const reaching = inOf.get(n.id) as Set<number>;
     for (const u of f.uses) {
@@ -583,49 +547,29 @@ export function computeDefUse(
     }
   }
 
-  // --- return-value nodes ---
-  const returnValueNodes = new Set<number>();
-  const body = getBody(build.fn);
-  const isExprBody = body !== undefined && !Node.isBlock(body);
-  for (const n of build.nodes) {
-    if (!n.ast) continue;
-    if (Node.isReturnStatement(n.ast) && n.ast.getExpression()) returnValueNodes.add(n.id);
-    else if (isExprBody && n.ast === body) returnValueNodes.add(n.id); // arrow expression body
-  }
-
   // --- formal-out routing: EXIT doubles as the SDG formal-out node ---
   // PARAM_OUT edges source at the callee's EXIT, so the value that leaves the function must flow
   // INTO it: return-value nodes carry the return value, module-global writes are live-out state.
   // Without these edges a slice descending a PARAM_OUT would dead-end at EXIT.
-  for (const r of [...returnValueNodes].sort((a, b) => a - b)) {
-    const k2 = `${r}>${build.exitId}>return`;
+  for (const r of [...data.returnValueNodes].sort((a, b) => a - b)) {
+    const k2 = `${r}>${data.exitId}>return`;
     if (!seen.has(k2)) {
       seen.add(k2);
-      ddg.push({ source: r, target: build.exitId, type: "DDG", var: "return" });
+      ddg.push({ source: r, target: data.exitId, type: "DDG", var: "return" });
     }
   }
-  for (const n of build.nodes) {
-    if (n.id === build.entryId) continue;
-    for (const d of facts.get(n.id)?.defs ?? []) {
+  for (const n of data.nodes) {
+    if (n.id === data.entryId) continue;
+    for (const d of effective.get(n.id)?.defs ?? []) {
       if (d.ref.baseKind !== "module") continue;
       const rendered = renderPath(d.ref);
-      const k2 = `${n.id}>${build.exitId}>${rendered}`;
+      const k2 = `${n.id}>${data.exitId}>${rendered}`;
       if (!seen.has(k2)) {
         seen.add(k2);
-        ddg.push({ source: n.id, target: build.exitId, type: "DDG", var: rendered });
+        ddg.push({ source: n.id, target: data.exitId, type: "DDG", var: rendered });
       }
     }
   }
 
-  const aliasRep = new Map<string, string>();
-  for (const f of facts.values()) {
-    for (const u of f.uses) aliasRep.set(u.key, find(u.key));
-    for (const d of f.defs) aliasRep.set(d.ref.key, find(d.ref.key));
-  }
-
-  return { ddg, facts, aliasRep, returnValueNodes };
-}
-
-function getBody(fn: Node): Node | undefined {
-  return (fn as unknown as { getBody?: () => Node | undefined }).getBody?.();
+  return { ddg, effective };
 }
diff --git a/src/dataflow/extract.ts b/src/dataflow/extract.ts
new file mode 100644
index 0000000..751ad53
--- /dev/null
+++ b/src/dataflow/extract.ts
@@ -0,0 +1,91 @@
+/**
+ * Stages 1–4 extraction — the AST-bound half of the level-3 pipeline, per callable:
+ * CFG (stage 1) → post-dominance + control dependence (stage 2) → def/use facts (stage 3's
+ * extraction half) → the serializable CallableGraphData projection.
+ *
+ * This is the unit that fans out over the worker pool: it has zero cross-function dependencies
+ * (embarrassingly parallel), and its output is plain data, so everything downstream — the
+ * reaching-defs solve, the summary wavefront, SDG assembly, emission — never touches an AST
+ * again. The same function serves the sequential (--jobs 1) path against the main-thread
+ * project, which is what makes N-vs-1 differential testing meaningful.
+ */
+import { Node, type Project } from "ts-morph";
+import { computeSignatureForDecl, type GraphNode } from "../schema";
+import { buildCfg } from "./cfg";
+import { extractFunctionFacts } from "./defuse";
+import { controlDependence, postDominators } from "./dominance";
+import type { CallableGraphData, FunctionCfgBuild } from "./model";
+
+/** Extract the full per-callable data product, or null when the callable has no body. */
+export function extractCallableData(signature: string, fn: Node, path: string, root: string, k: number): CallableGraphData | null {
+  const build = buildCfg(signature, fn);
+  if (!build) return null;
+
+  const cdg = controlDependence(build, postDominators(build)).sort(
+    (a, b) => a.source - b.source || a.target - b.target,
+  );
+  const { facts, aliasPairs, returnValueNodes } = extractFunctionFacts(build, root, k);
+
+  return {
+    signature,
+    path,
+    nodes: build.nodes.map((n) => emitNode(n.id, n.kind, n.ast, build)),
+    edges: [...build.edges].sort((a, b) => a.source - b.source || a.target - b.target || a.kind.localeCompare(b.kind)),
+    cdg,
+    entryId: build.entryId,
+    exitId: build.exitId,
+    paramIds: build.paramIds,
+    hasRestParam: hasRestParam(build),
+    facts,
+    aliasPairs,
+    returnValueNodes,
+  };
+}
+
+/**
+ * Walk source files and index callable declarations by canonical signature — the same
+ * computeSignatureForDecl the symbol table and call graph use, so keys byte-match. For
+ * `const f = () => {}` the signature keys the VariableDeclaration but the CFG is built from the
+ * initializer (the node that owns parameters and body). Restrict with `onlyFiles` (absolute
+ * paths) when a worker owns just a partition of the project.
+ */
+export function indexCallableDecls(project: Project, root: string, onlyFiles?: Set<string>): Map<string, Node> {
+  const idx = new Map<string, Node>();
+  for (const sf of project.getSourceFiles()) {
+    const fp = sf.getFilePath();
+    if (sf.isDeclarationFile() || fp.includes("/node_modules/")) continue;
+    if (onlyFiles && !onlyFiles.has(fp)) continue;
+    sf.forEachDescendant((n) => {
+      if (
+        Node.isFunctionDeclaration(n) ||
+        Node.isMethodDeclaration(n) ||
+        Node.isConstructorDeclaration(n) ||
+        Node.isGetAccessorDeclaration(n) ||
+        Node.isSetAccessorDeclaration(n)
+      ) {
+        const sig = computeSignatureForDecl(n, root);
+        if (sig && !idx.has(sig)) idx.set(sig, n);
+      } else if (Node.isVariableDeclaration(n)) {
+        const init = n.getInitializer();
+        if (init && (Node.isArrowFunction(init) || Node.isFunctionExpression(init))) {
+          const sig = computeSignatureForDecl(n, root);
+          if (sig && !idx.has(sig)) idx.set(sig, init);
+        }
+      }
+    });
+  }
+  return idx;
+}
+
+function emitNode(id: number, kind: GraphNode["kind"], ast: Node | null, build: FunctionCfgBuild): GraphNode {
+  const target = ast ?? build.fn; // ENTRY/EXIT carry the whole callable's span
+  const s = build.sf.getLineAndColumnAtPos(target.getStart());
+  const e = build.sf.getLineAndColumnAtPos(target.getEnd());
+  return { id, kind, start_line: s.line, start_column: s.column, end_line: e.line, end_column: e.column };
+}
+
+function hasRestParam(build: FunctionCfgBuild): boolean {
+  const params = (build.fn as unknown as { getParameters?: () => Node[] }).getParameters?.() ?? [];
+  const last = params[params.length - 1];
+  return last !== undefined && Node.isParameterDeclaration(last) && last.isRestParameter();
+}
diff --git a/src/dataflow/index.ts b/src/dataflow/index.ts
index d3a27ce..8993537 100644
--- a/src/dataflow/index.ts
+++ b/src/dataflow/index.ts
@@ -1,18 +1,24 @@
 /**
  * Level 3 — the program-graphs pipeline (stages 1–7 of the dataflow contract), run only at
- * `-a 3` after the symbol table and call graph exist:
+ * `-a 3` after the symbol table exists, structured for the contract's parallel execution model:
  *
- *   identity map (signature → AST callable)         — the same signatureOf() canonicalizer
- *   → stage 1  CFG per callable                     (cfg.ts)
- *   → stage 2  post-dominance + control dependence  (dominance.ts)
- *   → stage 3  access paths + reaching defs → DDG   (defuse.ts, re-run inside the fixpoint)
- *   → stage 5  SCC condensation of the call graph   (summaries.ts)
- *   → stage 6  bottom-up relational summaries       (summaries.ts)
- *   → stage 4+7  PDG assembly + SDG edges           (here + sdg.ts)
- *   → emission of the `program_graphs` section, scoped by `--graphs`
+ *   startExtraction (stages 1–4)   — embarrassingly parallel per callable: fanned out over a
+ *                                    Bun worker pool, partitioned by file. Kicked off BEFORE the
+ *                                    call-graph solve on the main thread (core.ts), so the two
+ *                                    run concurrently and join before summaries.
+ *   buildProgramGraphs (stages 5–7) — joins the extraction, maps call sites onto nodes (needs
+ *                                    the provider-backfilled callee signatures), then composes
+ *                                    summaries as a Kahn-style ready-queue WAVEFRONT over the
+ *                                    Tarjan SCC condensation DAG: an SCC dispatches the moment
+ *                                    its callee SCCs are done; the SCC (its internal fixpoint)
+ *                                    is the atomic unit, one worker each. SDG assembly and
+ *                                    emission close it out.
  *
- * Determinism: callables are processed in sorted-signature order, node ids are source-span
- * ordered, and every edge list is collect-then-sorted before emission.
+ * `--jobs 1` is the fully sequential debug mode (no workers, main-thread project reused, SCCs
+ * processed in Tarjan order) and the differential oracle: `--jobs N` must emit byte-identical
+ * output, which holds because ids are span-ordered (never discovery-ordered), every edge list is
+ * collect-then-sorted, and sccFixpoint is a pure function of its inputs. Worker failure at any
+ * point degrades to the sequential path — parallelism is an optimization, not a dependency.
  *
  * Summaries (with their callee dependency edges and the owning module's content hash) are
  * persisted to `<cache_dir>/graphs_summaries.json` — recorded from day one so incremental
@@ -20,11 +26,11 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { Node, ts, type Project, type SourceFile } from "ts-morph";
+import type { Project } from "ts-morph";
 import type { AnalysisOptions } from "../options";
 import {
   PROGRAM_GRAPHS_SCHEMA_VERSION,
-  computeSignatureForDecl,
+  fileKeyOf,
   type FunctionGraphs,
   type GraphNode,
   type PdgEdge,
@@ -36,169 +42,334 @@ import {
   type TSNamespace,
 } from "../schema";
 import type { Logger } from "../utils";
-import { buildCfg } from "./cfg";
-import { controlDependence, postDominators } from "./dominance";
-import type { FunctionCfgBuild } from "./model";
-import { type CallSiteRef, composeSummaries } from "./summaries";
+import { extractCallableData, indexCallableDecls } from "./extract";
+import type { CallableGraphData } from "./model";
+import { WorkerPool } from "./pool";
 import { assembleSdg } from "./sdg";
+import {
+  callAdjacency,
+  sccFixpoint,
+  tarjanSccs,
+  type CallSiteRef,
+  type FunctionSummary,
+} from "./summaries";
+import type { ExtractTask, SolveTask, SolveTaskResult } from "./worker";
 
 export { backwardSlice, type SliceCriterion } from "./slice";
 
-export interface BuildGraphsArgs {
-  project: Project;
-  symbol_table: Record<string, TSModule>;
-  opts: AnalysisOptions;
-  log: Logger;
+// ------------------------------------------------------------------------------------------------
+// Stage 1–4 extraction (started early so it overlaps the call-graph solve)
+// ------------------------------------------------------------------------------------------------
+
+export interface ExtractionHandle {
+  promise: Promise<Map<string, CallableGraphData>>;
+  pool: WorkerPool | null;
 }
 
-export function buildProgramGraphs({ project, symbol_table, opts, log }: BuildGraphsArgs): ProgramGraphs {
-  const k = opts.graphFieldDepth;
-  const root = opts.input;
+export function startExtraction(
+  project: Project,
+  symbol_table: Record<string, TSModule>,
+  tsConfigFilePath: string | null,
+  opts: AnalysisOptions,
+  log: Logger,
+): ExtractionHandle {
+  const callables = collectCallables(symbol_table);
 
-  // ---- identity map: canonical signature → the function-like AST node that owns the body ----
-  const astIndex = indexCallableDecls(project, root);
+  // Partition callables by owning file (round-robin over the sorted file list) so each worker
+  // deeply visits only its share of the program. TSCallable.path is the declaration's ABSOLUTE
+  // file path; the graph data carries the project-relative file key.
+  const byFile = new Map<string, Array<{ signature: string; path: string; absPath: string }>>();
+  for (const [sig, c] of [...callables.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    const absPath = c.path;
+    const arr = byFile.get(absPath) ?? [];
+    arr.push({ signature: sig, path: fileKeyOf(absPath, opts.input).fileKey, absPath });
+    byFile.set(absPath, arr);
+  }
+  const files = [...byFile.keys()].sort();
 
-  // ---- collect symbol-table callables (the node universe) ----
-  const callables = new Map<string, TSCallable>();
-  for (const mod of Object.values(symbol_table)) collectModule(mod, callables);
+  // Auto (0) resolves to sequential: each extraction worker must materialize its own
+  // whole-program ts-morph project (ASTs can't cross the clone boundary), and measurement shows
+  // that project load dominates the parallelizable graph math well past mid-sized repos —
+  // e.g. self-analysis (36 files, 211 callables) runs 2.5× SLOWER at -j 14. An explicit -j N is
+  // therefore an opt-in for large codebases (and how the differential test forces the worker
+  // path); correctness is guarded either way by the byte-identical N-vs-1 gate.
+  const jobs = opts.jobs === 0 ? 1 : opts.jobs;
 
-  // ---- stage 1: CFGs, in deterministic signature order ----
-  const builds = new Map<string, FunctionCfgBuild>();
-  for (const sig of [...callables.keys()].sort()) {
-    const fn = astIndex.get(sig);
-    if (!fn) continue; // bodiless (interface/abstract/ambient/implicit) or unmatchable
-    const build = buildCfg(sig, fn);
-    if (build) builds.set(sig, build);
-  }
-  log.info(`program graphs: ${builds.size} callables (of ${callables.size} in the symbol table)`);
-
-  // ---- map recorded call sites onto CFG statement nodes ----
-  const callSites = new Map<string, CallSiteRef[]>();
-  for (const [sig, build] of builds) {
-    const refs: CallSiteRef[] = [];
-    for (const site of (callables.get(sig) as TSCallable).call_sites) {
-      const nodeId = containingNode(build, site);
-      if (nodeId === null) continue;
-      refs.push({ nodeId, callee: site.callee_signature, argCount: site.argument_types.length });
-    }
-    refs.sort((a, b) => a.nodeId - b.nodeId || (a.callee ?? "").localeCompare(b.callee ?? ""));
-    callSites.set(sig, refs);
+  if (jobs <= 1) {
+    return { promise: Promise.resolve(extractSequential(project, callables, opts)), pool: null };
   }
+  const workerCount = Math.max(1, Math.min(jobs, files.length));
 
-  // ---- stages 5–6: SCC condensation + summary fixpoint (re-runs stage 3 per iteration) ----
-  const { summaries, defUse, sccs } = composeSummaries(builds, callSites, root, k, log);
-  log.debug(`program graphs: ${sccs.length} SCCs, largest ${Math.max(0, ...sccs.map((s) => s.length))}`);
-
-  // ---- stages 2 + 4: control dependence, PDG assembly; emission per --graphs selector ----
-  const wantCfg = opts.graphs.includes("cfg");
-  const wantPdg = opts.graphs.includes("pdg");
-  const wantDfg = opts.graphs.includes("dfg");
-  const wantSdg = opts.graphs.includes("sdg");
-
-  const functions: Record<string, FunctionGraphs> = {};
-  for (const [sig, build] of [...builds.entries()].sort(([a], [b]) => a.localeCompare(b))) {
-    const fg: FunctionGraphs = {};
-    if (wantCfg) {
-      fg.cfg = {
-        nodes: build.nodes.map((n) => emitNode(n.id, n.kind, n.ast, build)),
-        edges: [...build.edges].sort((a, b) => a.source - b.source || a.target - b.target || a.kind.localeCompare(b.kind)),
-      };
-    }
-    if (wantPdg || wantDfg) {
-      const edges: PdgEdge[] = [];
-      if (wantPdg) edges.push(...controlDependence(build, postDominators(build)));
-      edges.push(...(defUse.get(sig)?.ddg ?? []));
-      fg.pdg = {
-        edges: edges.sort(
-          (a, b) =>
-            a.source - b.source || a.target - b.target || a.type.localeCompare(b.type) || (a.var ?? "").localeCompare(b.var ?? ""),
-        ),
-      };
-    }
-    functions[sig] = fg;
+  let pool: WorkerPool;
+  try {
+    pool = new WorkerPool(workerCount);
+  } catch (e) {
+    log.warn(`graph workers unavailable (${(e as Error).message}); extracting sequentially`);
+    return { promise: Promise.resolve(extractSequential(project, callables, opts)), pool: null };
   }
 
-  const sdg_edges = wantSdg ? assembleSdg(builds, callSites, summaries) : [];
+  const partitions: Array<Array<{ signature: string; path: string; absPath: string }>> = Array.from(
+    { length: workerCount },
+    () => [],
+  );
+  files.forEach((f, i) => partitions[i % workerCount]?.push(...(byFile.get(f) ?? [])));
 
-  persistSummaries(opts, symbol_table, callables, summaries, k, log);
+  const handle: ExtractionHandle = { promise: Promise.resolve(new Map()), pool };
+  handle.promise = Promise.all(
+    partitions
+      .filter((p) => p.length)
+      .map((sigs) => {
+        const task: ExtractTask = {
+          type: "extract",
+          root: opts.input,
+          tsConfigFilePath,
+          skipTests: opts.skipTests,
+          k: opts.graphFieldDepth,
+          sigs,
+        };
+        return pool.exec<CallableGraphData[]>(task);
+      }),
+  )
+    .then((chunks) => {
+      const out = new Map<string, CallableGraphData>();
+      for (const chunk of chunks) for (const d of chunk) out.set(d.signature, d);
+      if (out.size === 0 && callables.size > 0) {
+        // Workers "succeeding" with nothing means their view of the project diverged from the
+        // main thread's — treat it as a failure, never as an empty program.
+        throw new Error("workers returned no callables");
+      }
+      return out;
+    })
+    .catch((e: Error) => {
+      // Degrade, never fail: retire the pool (so the wavefront goes sequential too — a pool
+      // that failed extraction must not be trusted with, or dangle, further tasks) and
+      // recompute on the main-thread project.
+      log.warn(`graph extraction workers failed (${e.message}); falling back to sequential`);
+      handle.pool?.close();
+      handle.pool = null;
+      return extractSequential(project, callables, opts);
+    });
 
-  return { schema_version: PROGRAM_GRAPHS_SCHEMA_VERSION, k_limit: k, functions, sdg_edges };
+  return handle;
+}
+
+function extractSequential(
+  project: Project,
+  callables: Map<string, TSCallable>,
+  opts: AnalysisOptions,
+): Map<string, CallableGraphData> {
+  const astIndex = indexCallableDecls(project, opts.input);
+  const out = new Map<string, CallableGraphData>();
+  for (const [sig, c] of [...callables.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    const fn = astIndex.get(sig);
+    if (!fn) continue; // bodiless (interface/abstract/ambient/implicit) or unmatchable
+    const data = extractCallableData(sig, fn, fileKeyOf(c.path, opts.input).fileKey, opts.input, opts.graphFieldDepth);
+    if (data) out.set(sig, data);
+  }
+  return out;
 }
 
 // ------------------------------------------------------------------------------------------------
-// Identity mapping
+// Stages 5–7 + emission
 // ------------------------------------------------------------------------------------------------
 
-/**
- * Walk every project source file and index callable declarations by canonical signature — the
- * same computeSignatureForDecl the symbol table and call graph use, so keys byte-match. For
- * `const f = () => {}` the signature keys the VariableDeclaration but the CFG is built from the
- * initializer (the node that owns parameters and body).
- */
-function indexCallableDecls(project: Project, root: string): Map<string, Node> {
-  const idx = new Map<string, Node>();
-  for (const sf of project.getSourceFiles()) {
-    const fp = sf.getFilePath();
-    if (sf.isDeclarationFile() || fp.includes("/node_modules/")) continue;
-    sf.forEachDescendant((n) => {
-      if (
-        Node.isFunctionDeclaration(n) ||
-        Node.isMethodDeclaration(n) ||
-        Node.isConstructorDeclaration(n) ||
-        Node.isGetAccessorDeclaration(n) ||
-        Node.isSetAccessorDeclaration(n)
-      ) {
-        const sig = computeSignatureForDecl(n, root);
-        if (sig && !idx.has(sig)) idx.set(sig, n);
-      } else if (Node.isVariableDeclaration(n)) {
-        const init = n.getInitializer();
-        if (init && (Node.isArrowFunction(init) || Node.isFunctionExpression(init))) {
-          const sig = computeSignatureForDecl(n, root);
-          if (sig && !idx.has(sig)) idx.set(sig, init);
-        }
+export async function buildProgramGraphs(
+  extraction: ExtractionHandle,
+  symbol_table: Record<string, TSModule>,
+  opts: AnalysisOptions,
+  log: Logger,
+): Promise<ProgramGraphs> {
+  try {
+    const datas = await extraction.promise;
+    const callables = collectCallables(symbol_table);
+    log.info(
+      `program graphs: ${datas.size} callables (of ${callables.size} in the symbol table), ` +
+        `workers=${extraction.pool ? extraction.pool.size : 1}`,
+    );
+
+    // Map recorded call sites onto CFG statement nodes (pure span containment — no AST). The
+    // callee signatures were backfilled by the call-graph provider while extraction ran.
+    const callSites = new Map<string, CallSiteRef[]>();
+    for (const [sig, data] of datas) {
+      const refs: CallSiteRef[] = [];
+      for (const site of (callables.get(sig) as TSCallable).call_sites) {
+        const nodeId = containingNode(data, site);
+        if (nodeId === null) continue;
+        refs.push({ nodeId, callee: site.callee_signature, argCount: site.argument_types.length });
       }
-    });
+      refs.sort((a, b) => a.nodeId - b.nodeId || (a.callee ?? "").localeCompare(b.callee ?? ""));
+      callSites.set(sig, refs);
+    }
+
+    // Stages 5–6: SCC condensation + the summary wavefront.
+    const { summaries, ddg, sccCount, largest } = await composeWavefront(datas, callSites, extraction.pool, log);
+    log.debug(`program graphs: ${sccCount} SCCs, largest ${largest}`);
+
+    // Emission per --graphs selector.
+    const wantCfg = opts.graphs.includes("cfg");
+    const wantPdg = opts.graphs.includes("pdg");
+    const wantDfg = opts.graphs.includes("dfg");
+    const wantSdg = opts.graphs.includes("sdg");
+
+    const functions: Record<string, FunctionGraphs> = {};
+    for (const [sig, data] of [...datas.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+      const fg: FunctionGraphs = {};
+      if (wantCfg) fg.cfg = { nodes: data.nodes, edges: data.edges };
+      if (wantPdg || wantDfg) {
+        const edges: PdgEdge[] = [];
+        if (wantPdg) edges.push(...data.cdg);
+        edges.push(...(ddg.get(sig) ?? []));
+        fg.pdg = {
+          edges: edges.sort(
+            (a, b) =>
+              a.source - b.source ||
+              a.target - b.target ||
+              a.type.localeCompare(b.type) ||
+              (a.var ?? "").localeCompare(b.var ?? ""),
+          ),
+        };
+      }
+      functions[sig] = fg;
+    }
+
+    const sdg_edges = wantSdg ? assembleSdg(datas, callSites, summaries) : [];
+
+    persistSummaries(opts, symbol_table, callables, summaries, log);
+
+    return { schema_version: PROGRAM_GRAPHS_SCHEMA_VERSION, k_limit: opts.graphFieldDepth, functions, sdg_edges };
+  } finally {
+    extraction.pool?.close();
   }
-  return idx;
 }
 
 // ------------------------------------------------------------------------------------------------
-// Call-site → CFG-node mapping
+// The summary wavefront: Kahn-style ready queue over the SCC condensation DAG
 // ------------------------------------------------------------------------------------------------
 
-/** The innermost CFG node whose AST span contains the recorded call site, or null. */
-function containingNode(build: FunctionCfgBuild, site: TSCallsite): number | null {
-  const pos = positionOf(build.sf, site.start_line, site.start_column);
-  if (pos === null) return null;
-  let best: { id: number; len: number } | null = null;
-  for (const n of build.nodes) {
-    if (!n.ast) continue;
-    const start = n.ast.getStart();
-    const end = n.ast.getEnd();
-    if (pos < start || pos >= end) continue;
-    const len = end - start;
-    if (!best || len < best.len) best = { id: n.id, len };
+async function composeWavefront(
+  datas: Map<string, CallableGraphData>,
+  callSites: Map<string, CallSiteRef[]>,
+  pool: WorkerPool | null,
+  log: Logger,
+): Promise<{ summaries: Map<string, FunctionSummary>; ddg: Map<string, PdgEdge[]>; sccCount: number; largest: number }> {
+  const sigs = [...datas.keys()].sort();
+  const adj = callAdjacency(sigs, callSites, (s) => datas.has(s));
+  const sccs = tarjanSccs(sigs, adj); // emitted callees-first
+  const largest = Math.max(0, ...sccs.map((s) => s.length));
+
+  const summaries = new Map<string, FunctionSummary>();
+  const ddg = new Map<string, PdgEdge[]>();
+
+  const solveInline = (members: string[]): void => {
+    const res = sccFixpoint(
+      members.map((m) => datas.get(m) as CallableGraphData),
+      callSites,
+      summaries,
+    );
+    for (const [k, v] of res.summaries) summaries.set(k, v);
+    for (const [k, v] of res.ddg) ddg.set(k, v);
+  };
+
+  if (!pool) {
+    // Sequential debug mode: Tarjan order IS a valid wavefront linearization.
+    for (const scc of sccs) solveInline(scc);
+    return { summaries, ddg, sccCount: sccs.length, largest };
   }
-  return best?.id ?? null;
-}
 
-function positionOf(sf: SourceFile, line: number, column: number): number | null {
+  // Condensation DAG: per-SCC dependency counters (callee SCCs must finish first) + reverse
+  // index (callee SCC → dependent caller SCCs) so completions decrement exactly their waiters.
+  const sccOf = new Map<string, number>();
+  sccs.forEach((scc, i) => scc.forEach((sig) => sccOf.set(sig, i)));
+  const pendingDeps: number[] = sccs.map(() => 0);
+  const dependents: number[][] = sccs.map(() => []);
+  sccs.forEach((scc, i) => {
+    const calleeSccs = new Set<number>();
+    for (const sig of scc) {
+      for (const callee of adj.get(sig) ?? []) {
+        const j = sccOf.get(callee);
+        if (j !== undefined && j !== i) calleeSccs.add(j);
+      }
+    }
+    pendingDeps[i] = calleeSccs.size;
+    for (const j of calleeSccs) dependents[j]?.push(i);
+  });
+
+  const ready: number[] = [];
+  sccs.forEach((_, i) => {
+    if (pendingDeps[i] === 0) ready.push(i);
+  });
+
+  const dispatch = (i: number): Promise<{ i: number; res: SolveTaskResult }> => {
+    const members = sccs[i] as string[];
+    // Ship only what the SCC needs: its members' data/call sites + its callees' summaries.
+    const calleeSummaries: Array<[string, FunctionSummary]> = [];
+    for (const sig of members) {
+      for (const callee of adj.get(sig) ?? []) {
+        const s = summaries.get(callee);
+        if (s) calleeSummaries.push([callee, s]);
+      }
+    }
+    const task: SolveTask = {
+      type: "solve",
+      members: members.map((m) => datas.get(m) as CallableGraphData),
+      callSites: members.map((m) => [m, callSites.get(m) ?? []]),
+      calleeSummaries,
+    };
+    return pool.exec<SolveTaskResult>(task).then((res) => ({ i, res }));
+  };
+
   try {
-    return ts.getPositionOfLineAndCharacter(sf.compilerNode, line - 1, column - 1);
-  } catch {
-    return null;
+    const inflight = new Map<number, Promise<{ i: number; res: SolveTaskResult }>>();
+    while (ready.length || inflight.size) {
+      while (ready.length && inflight.size < pool.size) {
+        const i = ready.shift() as number;
+        inflight.set(i, dispatch(i));
+      }
+      const { i, res } = await Promise.race(inflight.values());
+      inflight.delete(i);
+      for (const [k, v] of res.summaries) summaries.set(k, v);
+      for (const [k, v] of res.ddg) ddg.set(k, v);
+      for (const dep of dependents[i] ?? []) {
+        pendingDeps[dep] = (pendingDeps[dep] as number) - 1;
+        if (pendingDeps[dep] === 0) ready.push(dep);
+      }
+    }
+  } catch (e) {
+    // Degrade, never fail: redo the whole composition sequentially (pure functions — cheap-ish).
+    log.warn(`summary wavefront workers failed (${(e as Error).message}); recomposing sequentially`);
+    summaries.clear();
+    ddg.clear();
+    for (const scc of sccs) solveInline(scc);
   }
+
+  return { summaries, ddg, sccCount: sccs.length, largest };
 }
 
 // ------------------------------------------------------------------------------------------------
-// Emission helpers
+// Call-site → CFG-node mapping (span containment on serialized nodes)
 // ------------------------------------------------------------------------------------------------
 
-function emitNode(id: number, kind: GraphNode["kind"], ast: Node | null, build: FunctionCfgBuild): GraphNode {
-  const target = ast ?? build.fn; // ENTRY/EXIT carry the whole callable's span
-  const s = build.sf.getLineAndColumnAtPos(target.getStart());
-  const e = build.sf.getLineAndColumnAtPos(target.getEnd());
-  return { id, kind, start_line: s.line, start_column: s.column, end_line: e.line, end_column: e.column };
+/** The innermost non-synthetic CFG node whose span contains the recorded call site, or null. */
+function containingNode(data: CallableGraphData, site: TSCallsite): number | null {
+  let best: { id: number; span: number } | null = null;
+  for (const n of data.nodes) {
+    if (n.kind === "entry" || n.kind === "exit") continue;
+    if (!containsPos(n, site.start_line, site.start_column)) continue;
+    const span = spanSize(n);
+    if (!best || span < best.span) best = { id: n.id, span };
+  }
+  return best?.id ?? null;
+}
+
+function containsPos(n: GraphNode, line: number, column: number): boolean {
+  if (line < n.start_line || line > n.end_line) return false;
+  if (line === n.start_line && column < n.start_column) return false;
+  if (line === n.end_line && column >= n.end_column) return false;
+  return true;
+}
+
+function spanSize(n: GraphNode): number {
+  return (n.end_line - n.start_line) * 10_000 + (n.end_column - n.start_column);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -209,8 +380,7 @@ function persistSummaries(
   opts: AnalysisOptions,
   symbol_table: Record<string, TSModule>,
   callables: Map<string, TSCallable>,
-  summaries: Map<string, import("./summaries").FunctionSummary>,
-  k: number,
+  summaries: Map<string, FunctionSummary>,
   log: Logger,
 ): void {
   try {
@@ -219,12 +389,14 @@ function persistSummaries(
     const entries: Record<string, unknown> = {};
     for (const sig of [...summaries.keys()].sort()) {
       const c = callables.get(sig);
+      // TSCallable.path is absolute; the symbol table is keyed by the project-relative file key.
+      const fileKey = c ? fileKeyOf(c.path, opts.input).fileKey : null;
       entries[sig] = {
         ...summaries.get(sig),
-        content_hash: (c && symbol_table[c.path]?.content_hash) ?? null,
+        content_hash: (fileKey && symbol_table[fileKey]?.content_hash) ?? null,
       };
     }
-    const payload = { schema_version: PROGRAM_GRAPHS_SCHEMA_VERSION, k_limit: k, summaries: entries };
+    const payload = { schema_version: PROGRAM_GRAPHS_SCHEMA_VERSION, k_limit: opts.graphFieldDepth, summaries: entries };
     fs.writeFileSync(path.join(cacheDir, "graphs_summaries.json"), JSON.stringify(payload, null, 2));
   } catch (e) {
     log.warn(`could not persist graph summaries: ${(e as Error).message}`);
@@ -235,6 +407,12 @@ function persistSummaries(
 // Symbol-table collection (signature → callable), recursing through every container kind
 // ------------------------------------------------------------------------------------------------
 
+function collectCallables(symbol_table: Record<string, TSModule>): Map<string, TSCallable> {
+  const out = new Map<string, TSCallable>();
+  for (const mod of Object.values(symbol_table)) collectModule(mod, out);
+  return out;
+}
+
 function collectModule(mod: TSModule, out: Map<string, TSCallable>): void {
   for (const f of Object.values(mod.functions)) collectCallable(f, out);
   for (const c of Object.values(mod.classes)) collectClass(c, out);
diff --git a/src/dataflow/model.ts b/src/dataflow/model.ts
index 663dad0..8663f6f 100644
--- a/src/dataflow/model.ts
+++ b/src/dataflow/model.ts
@@ -1,10 +1,19 @@
 /**
- * Internal (non-emitted) working model shared by the level-3 dataflow stages. The emitted shapes
- * live in schema/graphs.ts; everything here additionally keeps the ts-morph AST links the later
- * stages (def-use, summaries, SDG) need, and is dropped before serialization.
+ * Internal working model shared by the level-3 dataflow stages. The emitted shapes live in
+ * schema/graphs.ts.
+ *
+ * Two tiers, split along the worker boundary:
+ *  - `FunctionCfgBuild` is AST-linked (ts-morph nodes) and never leaves the thread that parsed.
+ *  - `CallableGraphData` is the plain-data projection of everything downstream stages need —
+ *    structured-clone/JSON-safe, so stage-1–4 extraction can fan out over a worker pool and the
+ *    summary wavefront can run on data alone (no AST access after extraction).
  */
 import type { Node, SourceFile } from "ts-morph";
-import type { CfgEdge, GraphNodeKind } from "../schema";
+import type { CfgEdge, GraphNode, GraphNodeKind, PdgEdge } from "../schema";
+
+// ------------------------------------------------------------------------------------------------
+// AST-linked build product (stage 1, thread-local)
+// ------------------------------------------------------------------------------------------------
 
 /** A CFG node with its AST link. `ast` is null only for the synthetic ENTRY/EXIT pair. */
 export interface DfNode {
@@ -13,7 +22,7 @@ export interface DfNode {
   ast: Node | null;
 }
 
-/** The per-callable CFG build product (stage 1), input to every later stage. */
+/** The per-callable CFG build product (stage 1), input to fact extraction. */
 export interface FunctionCfgBuild {
   signature: string;
   /** The function-like AST node (FunctionDeclaration / Method / Ctor / accessor / arrow / fn-expr). */
@@ -28,15 +37,111 @@ export interface FunctionCfgBuild {
   paramIds: number[];
 }
 
-/** Successor/predecessor adjacency over CFG edges, built on demand. */
-export function adjacency(build: FunctionCfgBuild): { succ: Map<number, number[]>; pred: Map<number, number[]> } {
+// ------------------------------------------------------------------------------------------------
+// Access paths (plain data — labels every DDG edge and summary entry)
+// ------------------------------------------------------------------------------------------------
+
+export type BaseKind = "local" | "param" | "this" | "captured" | "module";
+
+export interface PathRef {
+  /** Unique base identity: decl-position for locals/params/captured, canonical path for module, "this". */
+  key: string;
+  /** Human label for the base (the variable name / canonical module path). */
+  label: string;
+  baseKind: BaseKind;
+  fields: string[]; // "f" | "[*]" | "*" (trailing truncation star)
+}
+
+export function renderPath(p: PathRef): string {
+  let s = p.label;
+  for (const f of p.fields) s += f === "[*]" ? "[*]" : `.${f}`;
+  return s;
+}
+
+/** A global (module-binding) path as carried by summaries: canonical base + fields. */
+export interface GlobalPath {
+  key: string; // == the canonical `<modulePrefix>.<name>` label
+  fields: string[];
+}
+
+export function renderGlobal(g: GlobalPath): string {
+  return renderPath({ key: g.key, label: g.key, baseKind: "module", fields: g.fields });
+}
+
+/** May two field lists overlap? "*" (truncation) matches any tail; "[*]" matches any one step. */
+export function fieldsMayAlias(a: string[], b: string[]): boolean {
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) {
+    const x = a[i] as string;
+    const y = b[i] as string;
+    if (x === "*" || y === "*") return true;
+    if (x === "[*]" || y === "[*]") continue; // dynamic index may hit any member
+    if (x !== y) return false;
+  }
+  return true; // one path is a prefix of the other (whole-object vs member)
+}
+
+// ------------------------------------------------------------------------------------------------
+// Per-node dataflow facts (plain data)
+// ------------------------------------------------------------------------------------------------
+
+export interface DefFact {
+  ref: PathRef;
+  /** Strong defs kill; only whole-base writes of locals/params qualify (field writes are weak). */
+  strong: boolean;
+}
+
+export interface NodeFacts {
+  defs: DefFact[];
+  uses: PathRef[];
+}
+
+/** Transitive global effects of a call, applied at its callsite node during the solve. */
+export interface CallEffects {
+  reads: GlobalPath[];
+  writes: GlobalPath[];
+}
+
+// ------------------------------------------------------------------------------------------------
+// The serializable per-callable projection (crosses the worker boundary)
+// ------------------------------------------------------------------------------------------------
+
+/**
+ * Everything stages 5–8 and emission need, as plain data: the emitted CFG (nodes carry source
+ * spans, not AST links), the CDG, the extracted per-node facts, the copy-alias pairs, and the
+ * structural metadata. Producing this once per callable is the AST-bound work; every fixpoint
+ * iteration after it is pure data.
+ */
+export interface CallableGraphData {
+  signature: string;
+  /** Owning module file key (project-relative POSIX path with extension). */
+  path: string;
+  /** Emitted-shape nodes, index == id (ENTRY first, EXIT last). */
+  nodes: GraphNode[];
+  edges: CfgEdge[];
+  /** Control-dependence edges (stage 2), computed at extraction time. */
+  cdg: PdgEdge[];
+  entryId: number;
+  exitId: number;
+  paramIds: number[];
+  hasRestParam: boolean;
+  /** Extracted defs/uses per node id (pairs, for clone-safety). */
+  facts: Array<[number, NodeFacts]>;
+  /** Copy-alias unions discovered during extraction (`const q = p`). */
+  aliasPairs: Array<[string, string]>;
+  /** Nodes that produce the function's return value. */
+  returnValueNodes: number[];
+}
+
+/** Successor/predecessor adjacency over serialized CFG edges. */
+export function dataAdjacency(data: CallableGraphData): { succ: Map<number, number[]>; pred: Map<number, number[]> } {
   const succ = new Map<number, number[]>();
   const pred = new Map<number, number[]>();
-  for (const n of build.nodes) {
+  for (const n of data.nodes) {
     succ.set(n.id, []);
     pred.set(n.id, []);
   }
-  for (const e of build.edges) {
+  for (const e of data.edges) {
     succ.get(e.source)?.push(e.target);
     pred.get(e.target)?.push(e.source);
   }
diff --git a/src/dataflow/pool.ts b/src/dataflow/pool.ts
new file mode 100644
index 0000000..1046247
--- /dev/null
+++ b/src/dataflow/pool.ts
@@ -0,0 +1,104 @@
+/**
+ * A minimal fixed-size worker pool over Bun's Worker (one in-flight task per worker, FIFO
+ * queue). Used by the level-3 pipeline for the stage-1–4 extraction fan-out and the SCC
+ * wavefront. Construction or task failure is surfaced to the caller, which falls back to the
+ * sequential (--jobs 1) path — parallelism is an optimization, never a correctness dependency.
+ *
+ * Failure discipline: a worker that errors is retired (never re-idled), and when the last live
+ * worker dies every queued task is rejected — a task must never sit in the queue with nothing
+ * left to run it, or the awaiting pipeline would dangle unresolved and the process could exit
+ * without emitting output.
+ */
+
+interface Pending {
+  resolve: (v: unknown) => void;
+  reject: (e: Error) => void;
+}
+
+/**
+ * The worker entry URL differs between dev and the compiled binary. Dev/test runs load the
+ * TypeScript source relative to this module. `bun build --compile` embeds the extra entrypoint
+ * under its BUILT name and its path relative to the entries' common root (src/) inside the
+ * `$bunfs` virtual filesystem — `src/dataflow/worker.ts` → `/$bunfs/root/dataflow/worker.js`,
+ * while `import.meta.url` here is the bundled main (`/$bunfs/root/<binary>`). Coupled to the
+ * `build` script's entry list in package.json; a mismatch degrades to the sequential path via
+ * the pool's failure fallback (with a warning), never to wrong output.
+ */
+function workerUrl(): string {
+  const compiled = import.meta.url.includes("$bunfs");
+  return new URL(compiled ? "./dataflow/worker.js" : "./worker.ts", import.meta.url).href;
+}
+
+export class WorkerPool {
+  private workers = new Set<Worker>();
+  private idle: Worker[] = [];
+  private pending = new Map<Worker, Pending>();
+  private queue: Array<{ msg: unknown; p: Pending }> = [];
+  private closed = false;
+
+  constructor(size: number) {
+    const url = workerUrl();
+    for (let i = 0; i < size; i++) {
+      const w = new Worker(url);
+      w.onmessage = (ev: MessageEvent) => this.settle(w, ev.data as { ok: boolean; result?: unknown; error?: string });
+      w.onerror = (ev: ErrorEvent) => this.retire(w, new Error(`worker error: ${ev.message ?? "unknown"}`));
+      this.workers.add(w);
+      this.idle.push(w);
+    }
+  }
+
+  get size(): number {
+    return this.workers.size;
+  }
+
+  exec<T>(msg: unknown): Promise<T> {
+    if (this.closed) return Promise.reject(new Error("worker pool is closed"));
+    if (this.workers.size === 0) return Promise.reject(new Error("worker pool has no live workers"));
+    return new Promise<T>((resolve, reject) => {
+      const p: Pending = { resolve: resolve as (v: unknown) => void, reject };
+      const w = this.idle.pop();
+      if (w) this.dispatch(w, msg, p);
+      else this.queue.push({ msg, p });
+    });
+  }
+
+  close(): void {
+    this.closed = true;
+    this.rejectQueue(new Error("worker pool closed"));
+    for (const w of this.workers) w.terminate();
+    this.workers.clear();
+    this.idle = [];
+  }
+
+  private dispatch(w: Worker, msg: unknown, p: Pending): void {
+    this.pending.set(w, p);
+    w.postMessage(msg);
+  }
+
+  private settle(w: Worker, reply: { ok: boolean; result?: unknown; error?: string }): void {
+    const p = this.pending.get(w);
+    this.pending.delete(w);
+    const next = this.queue.shift();
+    if (next) this.dispatch(w, next.msg, next.p);
+    else this.idle.push(w);
+    if (!p) return;
+    if (reply.ok) p.resolve(reply.result);
+    else p.reject(new Error(reply.error ?? "worker task failed"));
+  }
+
+  /** A worker died: fail its task, drop it from the pool, and never strand the queue. */
+  private retire(w: Worker, err: Error): void {
+    const p = this.pending.get(w);
+    this.pending.delete(w);
+    this.workers.delete(w);
+    this.idle = this.idle.filter((x) => x !== w);
+    w.terminate();
+    p?.reject(err);
+    if (this.workers.size === 0) this.rejectQueue(err);
+  }
+
+  private rejectQueue(err: Error): void {
+    for (const q of this.queue) q.p.reject(err);
+    this.queue = [];
+  }
+}
diff --git a/src/dataflow/sdg.ts b/src/dataflow/sdg.ts
index 696c7a3..600877f 100644
--- a/src/dataflow/sdg.ts
+++ b/src/dataflow/sdg.ts
@@ -1,6 +1,7 @@
 /**
  * Stage 7 — SDG assembly: stitch the per-function PDGs with interprocedural edges
- * (Horwitz–Reps–Binkley), all keyed by canonical `(signature, node_id)`.
+ * (Horwitz–Reps–Binkley), all keyed by canonical `(signature, node_id)`. Operates purely on the
+ * serialized CallableGraphData (no AST access).
  *
  * Call sites are collapsed onto their containing statement node (the node is both actual-in and
  * actual-out), so:
@@ -16,14 +17,12 @@
  * External / unresolved callees have no graphs to reference (no dangling endpoints — the
  * call-graph rule), so they contribute only conservative pass-through SUMMARY self-edges.
  */
-import { Node } from "ts-morph";
 import type { SdgEdge } from "../schema";
-import type { FunctionCfgBuild } from "./model";
+import { renderGlobal, type CallableGraphData } from "./model";
 import type { CallSiteRef, FunctionSummary } from "./summaries";
-import { renderGlobal } from "./defuse";
 
 export function assembleSdg(
-  builds: Map<string, FunctionCfgBuild>,
+  datas: Map<string, CallableGraphData>,
   callSites: Map<string, CallSiteRef[]>,
   summaries: Map<string, FunctionSummary>,
 ): SdgEdge[] {
@@ -36,10 +35,10 @@ export function assembleSdg(
     out.push(e);
   };
 
-  for (const caller of [...builds.keys()].sort()) {
+  for (const caller of [...datas.keys()].sort()) {
     for (const cs of callSites.get(caller) ?? []) {
       const at = (node: number): { signature: string; node: number } => ({ signature: caller, node });
-      const callee = cs.callee ? builds.get(cs.callee) : undefined;
+      const callee = cs.callee ? datas.get(cs.callee) : undefined;
 
       if (!callee || !cs.callee) {
         // External / unresolved: conservative pass-through — every argument may flow to the result.
@@ -53,11 +52,10 @@ export function assembleSdg(
       add({ source: at(cs.nodeId), target: { signature: calleeSig, node: callee.entryId }, type: "CALL" });
 
       // Positional PARAM_IN edges; extra arguments bind to a trailing rest parameter if there is one.
-      const rest = hasRestParam(callee);
       for (let i = 0; i < cs.argCount; i++) {
         let pIdx = i;
         if (pIdx >= callee.paramIds.length) {
-          if (!rest || callee.paramIds.length === 0) continue;
+          if (!callee.hasRestParam || callee.paramIds.length === 0) continue;
           pIdx = callee.paramIds.length - 1;
         }
         add({
@@ -112,9 +110,3 @@ export function assembleSdg(
       (a.var ?? "").localeCompare(b.var ?? ""),
   );
 }
-
-function hasRestParam(build: FunctionCfgBuild): boolean {
-  const params = (build.fn as unknown as { getParameters?: () => Node[] }).getParameters?.() ?? [];
-  const last = params[params.length - 1];
-  return last !== undefined && Node.isParameterDeclaration(last) && last.isRestParameter();
-}
diff --git a/src/dataflow/summaries.ts b/src/dataflow/summaries.ts
index 15ab21b..2bb791d 100644
--- a/src/dataflow/summaries.ts
+++ b/src/dataflow/summaries.ts
@@ -7,19 +7,28 @@
  * Summaries are node-granular — dependence is tracked between CFG nodes, not sub-expressions —
  * which keeps them sound-leaning and over-approximate (the contract's precision posture).
  *
- * Composition order is Tarjan's SCC emission order (callees before callers). Within an SCC
- * (mutual recursion), member summaries are co-defined: each member's def-use is recomputed with
- * the current callee summaries applied at its call sites (globals become extra uses/defs on the
- * callsite node), iterating to a monotone fixpoint. Termination: summary domains are finite —
- * argument indices are bounded by arity and global paths are k-limited — and grow monotonically.
+ * Everything here is pure data (CallableGraphData + prior summaries): fact extraction happened
+ * once at stage 1–4 time, so an SCC's fixpoint re-runs only the reaching-defs solve. That is
+ * what lets `sccFixpoint` be the atomic unit of the wavefront — dispatched to a worker or run
+ * inline, byte-identically (it is a pure function of its inputs).
+ *
+ * Within an SCC (mutual recursion), member summaries are co-defined, iterating to a monotone
+ * fixpoint. Termination: summary domains are finite — argument indices are bounded by arity and
+ * global paths are k-limited — and grow monotonically.
  *
  * External / unresolved callees: conservative pass-through — every argument may flow to the
  * result (applied at SDG/SUMMARY emission); their global effects are unmodeled (documented
  * unsoundness: npm internals are not analyzed).
  */
-import type { Logger } from "../utils";
-import { type CallEffects, type DefUseResult, type GlobalPath, computeDefUse, renderGlobal } from "./defuse";
-import type { FunctionCfgBuild } from "./model";
+import type { PdgEdge } from "../schema";
+import { solveDefUse } from "./defuse";
+import {
+  renderGlobal,
+  type CallEffects,
+  type CallableGraphData,
+  type GlobalPath,
+  type NodeFacts,
+} from "./model";
 
 /** A call site inside a callable, mapped onto its CFG statement node. */
 export interface CallSiteRef {
@@ -40,63 +49,51 @@ export interface FunctionSummary {
   deps: string[];
 }
 
-export interface SummaryResult {
+export interface SccResult {
   summaries: Map<string, FunctionSummary>;
-  /** The fixpoint def-use per callable (its DDG already reflects callee global effects). */
-  defUse: Map<string, DefUseResult>;
-  /** SCCs in composition (reverse-topological, callees-first) order — exposed for tests. */
-  sccs: string[][];
+  /** Each member's fixpoint DDG (already reflecting callee global effects) — what the PDG emits. */
+  ddg: Map<string, PdgEdge[]>;
 }
 
-export function composeSummaries(
-  builds: Map<string, FunctionCfgBuild>,
+/**
+ * Solve one SCC to its co-defined fixpoint, given the summaries of every callee SCC (which the
+ * wavefront guarantees are complete). Pure: same inputs ⇒ same outputs, on any thread.
+ */
+export function sccFixpoint(
+  members: CallableGraphData[],
   callSites: Map<string, CallSiteRef[]>,
-  root: string,
-  k: number,
-  log: Logger,
-): SummaryResult {
-  const sigs = [...builds.keys()].sort();
-  const adj = new Map<string, string[]>();
-  for (const s of sigs) {
-    const targets = new Set<string>();
-    for (const cs of callSites.get(s) ?? []) {
-      if (cs.callee && builds.has(cs.callee) && cs.callee !== s) targets.add(cs.callee);
-    }
-    adj.set(s, [...targets].sort());
-  }
+  calleeSummaries: Map<string, FunctionSummary>,
+): SccResult {
+  const sorted = [...members].sort((a, b) => a.signature.localeCompare(b.signature));
+  const memberSigs = new Set(sorted.map((m) => m.signature));
+  const summaries = new Map<string, FunctionSummary>(calleeSummaries);
+  const ddg = new Map<string, PdgEdge[]>();
 
-  const sccs = tarjan(sigs, adj); // emitted callees-first
-  const summaries = new Map<string, FunctionSummary>();
-  const defUse = new Map<string, DefUseResult>();
-
-  for (const scc of sccs) {
-    // Co-define the SCC members' summaries to a fixpoint (a singleton converges in one pass +
-    // one confirmation pass only when it is self-recursive; plain members need a single pass).
-    const members = [...scc].sort();
-    const selfReferential =
-      members.length > 1 ||
-      (callSites.get(members[0] as string) ?? []).some((cs) => cs.callee === members[0]);
-    let iterations = 0;
-    for (;;) {
-      let changed = false;
-      for (const sig of members) {
-        const build = builds.get(sig) as FunctionCfgBuild;
-        const effects = effectsFor(callSites.get(sig) ?? [], summaries);
-        const du = computeDefUse(build, root, k, effects);
-        const next = summarize(build, du, callSites.get(sig) ?? []);
-        if (!summaries.has(sig) || !sameSummary(summaries.get(sig) as FunctionSummary, next)) changed = true;
-        summaries.set(sig, next);
-        defUse.set(sig, du);
-      }
-      iterations++;
-      if (!changed || !selfReferential) break;
-      if (iterations > 100) {
-        log.warn(`summary fixpoint did not settle after ${iterations} iterations for SCC [${members.join(", ")}]`);
-        break;
-      }
+  const selfReferential =
+    sorted.length > 1 ||
+    (callSites.get(sorted[0]?.signature ?? "") ?? []).some((cs) => cs.callee === sorted[0]?.signature);
+
+  let iterations = 0;
+  for (;;) {
+    let changed = false;
+    for (const data of sorted) {
+      const effects = effectsFor(callSites.get(data.signature) ?? [], summaries);
+      const solved = solveDefUse(data, effects);
+      const next = summarize(data, solved.ddg, solved.effective, callSites.get(data.signature) ?? []);
+      const prev = summaries.get(data.signature);
+      if (!prev || !sameSummary(prev, next)) changed = true;
+      summaries.set(data.signature, next);
+      ddg.set(data.signature, solved.ddg);
     }
+    iterations++;
+    if (!changed || !selfReferential) break;
+    if (iterations > 100) break; // k-limited domains make this unreachable; hard backstop anyway
   }
-  return { summaries, defUse, sccs };
+
+  // Return only this SCC's summaries (callee entries were working state).
+  const own = new Map<string, FunctionSummary>();
+  for (const sig of memberSigs) own.set(sig, summaries.get(sig) as FunctionSummary);
+  return { summaries: own, ddg };
 }
 
 /** Project the current callee summaries onto a function's call sites as global read/write effects. */
@@ -114,13 +111,19 @@ function effectsFor(sites: CallSiteRef[], summaries: Map<string, FunctionSummary
   return out;
 }
 
-function summarize(build: FunctionCfgBuild, du: DefUseResult, _sites: CallSiteRef[]): FunctionSummary {
+function summarize(
+  data: CallableGraphData,
+  ddg: PdgEdge[],
+  effective: Map<number, NodeFacts>,
+  sites: CallSiteRef[],
+): FunctionSummary {
   // Forward DDG adjacency (def-node → use-node = "use-node depends on def-node").
   const fwd = new Map<number, Set<number>>();
-  for (const e of du.ddg) {
+  for (const e of ddg) {
     if (!fwd.has(e.source)) fwd.set(e.source, new Set());
     fwd.get(e.source)?.add(e.target);
   }
+  const returnValueNodes = new Set(data.returnValueNodes);
   const reaches = (starts: number[]): Set<number> => {
     const seen = new Set<number>(starts);
     const stack = [...starts];
@@ -136,22 +139,22 @@ function summarize(build: FunctionCfgBuild, du: DefUseResult, _sites: CallSiteRe
     return seen;
   };
   const touchesReturn = (starts: number[]): boolean => {
-    for (const n of reaches(starts)) if (du.returnValueNodes.has(n)) return true;
+    for (const n of reaches(starts)) if (returnValueNodes.has(n)) return true;
     return false;
   };
 
   const param_flows: number[] = [];
-  for (const [i, pid] of build.paramIds.entries()) {
+  for (const [i, pid] of data.paramIds.entries()) {
     if (touchesReturn([pid])) param_flows.push(i);
   }
 
   // Global reads/writes: module-kind uses/defs anywhere in the function. Callee effects were
-  // already injected into the facts by computeDefUse, so transitive effects fall out for free.
-  // ENTRY's synthetic ambient defs are initializations, not writes — exclude them.
+  // already overlaid by solveDefUse, so transitive effects fall out for free. ENTRY's synthetic
+  // ambient defs are initializations, not writes — exclude them.
   const readsByKey = new Map<string, GlobalPath>();
   const writesByKey = new Map<string, GlobalPath>();
   const usedAt = new Map<string, number[]>();
-  for (const [nodeId, f] of du.facts) {
+  for (const [nodeId, f] of effective) {
     for (const u of f.uses) {
       if (u.baseKind !== "module") continue;
       const g: GlobalPath = { key: u.key, fields: u.fields };
@@ -160,7 +163,7 @@ function summarize(build: FunctionCfgBuild, du: DefUseResult, _sites: CallSiteRe
       arr.push(nodeId);
       usedAt.set(u.key, arr);
     }
-    if (nodeId === build.entryId) continue;
+    if (nodeId === data.entryId) continue;
     for (const d of f.defs) {
       if (d.ref.baseKind !== "module") continue;
       const g: GlobalPath = { key: d.ref.key, fields: d.ref.fields };
@@ -175,7 +178,7 @@ function summarize(build: FunctionCfgBuild, du: DefUseResult, _sites: CallSiteRe
   }
 
   const deps = new Set<string>();
-  for (const cs of _sites) if (cs.callee) deps.add(cs.callee);
+  for (const cs of sites) if (cs.callee) deps.add(cs.callee);
 
   return {
     param_flows: param_flows.sort((a, b) => a - b),
@@ -198,7 +201,7 @@ function sameSummary(a: FunctionSummary, b: FunctionSummary): boolean {
 // Tarjan SCC — emission order is reverse-topological (an SCC is emitted after every SCC it calls).
 // ------------------------------------------------------------------------------------------------
 
-function tarjan(nodes: string[], adj: Map<string, string[]>): string[][] {
+export function tarjanSccs(nodes: string[], adj: Map<string, string[]>): string[][] {
   const index = new Map<string, number>();
   const low = new Map<string, number>();
   const onStack = new Set<string>();
@@ -235,3 +238,20 @@ function tarjan(nodes: string[], adj: Map<string, string[]>): string[][] {
   for (const v of nodes) if (!index.has(v)) strongconnect(v);
   return out;
 }
+
+/** Internal-call adjacency (caller → callees with graphs), the condensation input. */
+export function callAdjacency(
+  sigs: string[],
+  callSites: Map<string, CallSiteRef[]>,
+  hasGraph: (sig: string) => boolean,
+): Map<string, string[]> {
+  const adj = new Map<string, string[]>();
+  for (const s of sigs) {
+    const targets = new Set<string>();
+    for (const cs of callSites.get(s) ?? []) {
+      if (cs.callee && hasGraph(cs.callee) && cs.callee !== s) targets.add(cs.callee);
+    }
+    adj.set(s, [...targets].sort());
+  }
+  return adj;
+}
diff --git a/src/dataflow/worker.ts b/src/dataflow/worker.ts
new file mode 100644
index 0000000..90d377a
--- /dev/null
+++ b/src/dataflow/worker.ts
@@ -0,0 +1,96 @@
+/**
+ * Level-3 worker entry — runs on a Bun Worker thread. Two task kinds:
+ *
+ *  - "extract": stages 1–4 for a partition of the project's files. ts-morph ASTs cannot cross
+ *    the structured-clone boundary, so each worker materializes its own whole-program Project
+ *    (the checker needs every file for cross-file resolution; only the partition's files are
+ *    deeply visited) and returns plain CallableGraphData.
+ *  - "solve": one SCC's summary fixpoint (the wavefront's atomic unit) — pure data in, pure
+ *    data out, via the same sccFixpoint the sequential path uses.
+ *
+ * The pool treats any failure here as "fall back to sequential", so this file must never be a
+ * correctness dependency.
+ */
+import { Project } from "ts-morph";
+import type { PdgEdge } from "../schema";
+import { defaultCompilerOptions, discoverSourceFiles } from "../syntactic_analysis";
+import { extractCallableData, indexCallableDecls } from "./extract";
+import type { CallableGraphData } from "./model";
+import { sccFixpoint, type CallSiteRef, type FunctionSummary } from "./summaries";
+
+export interface ExtractTask {
+  type: "extract";
+  root: string;
+  tsConfigFilePath: string | null;
+  skipTests: boolean;
+  k: number;
+  /** The callables this worker owns: signature + module file key + absolute file path. */
+  sigs: Array<{ signature: string; path: string; absPath: string }>;
+}
+
+export interface SolveTask {
+  type: "solve";
+  members: CallableGraphData[];
+  callSites: Array<[string, CallSiteRef[]]>;
+  calleeSummaries: Array<[string, FunctionSummary]>;
+}
+
+export interface SolveTaskResult {
+  summaries: Array<[string, FunctionSummary]>;
+  ddg: Array<[string, PdgEdge[]]>;
+}
+
+export type WorkerTask = ExtractTask | SolveTask;
+
+// One Project per worker lifetime (keyed in case tasks ever mix targets).
+const projects = new Map<string, Project>();
+
+function projectFor(root: string, tsConfigFilePath: string | null, skipTests: boolean): Project {
+  const key = `${root}|${tsConfigFilePath ?? ""}|${skipTests}`;
+  let project = projects.get(key);
+  if (project) return project;
+  project = tsConfigFilePath
+    ? new Project({ tsConfigFilePath, skipAddingFilesFromTsConfig: true })
+    : new Project({ compilerOptions: defaultCompilerOptions() });
+  for (const f of discoverSourceFiles(root, skipTests)) {
+    try {
+      project.addSourceFileAtPath(f.absPath);
+    } catch {
+      // Same tolerance as the symbol-table builder: an unloadable file degrades, never crashes.
+    }
+  }
+  projects.set(key, project);
+  return project;
+}
+
+function runExtract(task: ExtractTask): CallableGraphData[] {
+  const project = projectFor(task.root, task.tsConfigFilePath, task.skipTests);
+  const onlyFiles = new Set(task.sigs.map((s) => s.absPath));
+  const idx = indexCallableDecls(project, task.root, onlyFiles);
+  const out: CallableGraphData[] = [];
+  for (const s of task.sigs) {
+    const fn = idx.get(s.signature);
+    if (!fn) continue;
+    const data = extractCallableData(s.signature, fn, s.path, task.root, task.k);
+    if (data) out.push(data);
+  }
+  return out;
+}
+
+function runSolve(task: SolveTask): SolveTaskResult {
+  const res = sccFixpoint(task.members, new Map(task.callSites), new Map(task.calleeSummaries));
+  return { summaries: [...res.summaries.entries()], ddg: [...res.ddg.entries()] };
+}
+
+declare var self: Worker;
+
+self.onmessage = (ev: MessageEvent) => {
+  const task = ev.data as WorkerTask;
+  try {
+    const result = task.type === "extract" ? runExtract(task) : runSolve(task);
+    self.postMessage({ ok: true, result });
+  } catch (e) {
+    const err = e as Error;
+    self.postMessage({ ok: false, error: err.stack ?? err.message });
+  }
+};
diff --git a/src/index.ts b/src/index.ts
index e5ef590..0d4a836 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -11,7 +11,7 @@ async function main(): Promise<void> {
       emitSchema(opts);
       return;
     }
-    const app = analyze(opts);
+    const app = await analyze(opts);
     await emit(app, opts);
   } catch (e) {
     const err = e as Error;
diff --git a/src/options/options.ts b/src/options/options.ts
index 1b711c2..fe909fd 100644
--- a/src/options/options.ts
+++ b/src/options/options.ts
@@ -27,6 +27,14 @@ export interface AnalysisOptions {
   graphs: GraphSelector[];
   /** k-limit for access-path depth in the level-3 dataflow (`--graph-field-depth`, default 3). */
   graphFieldDepth: number;
+  /**
+   * Worker parallelism for the level-3 pipeline (`-j/--jobs`). 0 = auto (currently sequential:
+   * each extraction worker must materialize its own whole-program ts-morph project, which
+   * measurably dominates the parallelizable graph math on small/mid repos); an explicit N ≥ 2
+   * opts in for large codebases; 1 = fully sequential (the debug mode and differential oracle —
+   * `--jobs N` output is byte-identical).
+   */
+  jobs: number;
   /** Restrict analysis to these files (project-relative or absolute). null ⇒ whole project. */
   targetFiles: string[] | null;
   /** Skip test trees (default true). */
diff --git a/src/syntactic_analysis/symbolTable.ts b/src/syntactic_analysis/symbolTable.ts
index 62f16a6..b7cdbc6 100644
--- a/src/syntactic_analysis/symbolTable.ts
+++ b/src/syntactic_analysis/symbolTable.ts
@@ -61,7 +61,8 @@ export function buildSymbolTable(
   return { project, symbol_table, files: buildFiles };
 }
 
-function defaultCompilerOptions(): ts.CompilerOptions {
+/** The fallback compiler options when the target has no tsconfig (shared with graph workers). */
+export function defaultCompilerOptions(): ts.CompilerOptions {
   return {
     target: ts.ScriptTarget.ES2022,
     module: ts.ModuleKind.ESNext,
diff --git a/test/dataflow.test.ts b/test/dataflow.test.ts
index c957dd6..155c23a 100644
--- a/test/dataflow.test.ts
+++ b/test/dataflow.test.ts
@@ -15,7 +15,7 @@ import type { CfgEdge, FunctionCfg, ProgramGraphs, SdgEdge } from "../src/schema
 
 const FIXTURE = path.resolve(import.meta.dir, "fixtures/dataflow-app");
 
-function options(level: 1 | 2 | 3, cacheDir: string): AnalysisOptions {
+function options(level: 1 | 2 | 3, cacheDir: string, jobs: number): AnalysisOptions {
   return {
     input: FIXTURE,
     output: null,
@@ -28,6 +28,7 @@ function options(level: 1 | 2 | 3, cacheDir: string): AnalysisOptions {
     analysisLevel: level,
     graphs: ["cfg", "dfg", "pdg", "sdg"],
     graphFieldDepth: 3,
+    jobs,
     targetFiles: null,
     skipTests: true,
     eager: true,
@@ -39,16 +40,16 @@ function options(level: 1 | 2 | 3, cacheDir: string): AnalysisOptions {
   };
 }
 
-function run(level: 1 | 2 | 3): ReturnType<typeof analyze> {
+async function run(level: 1 | 2 | 3, jobs = 1): Promise<Awaited<ReturnType<typeof analyze>>> {
   const cacheDir = fs.mkdtempSync(path.join(os.tmpdir(), "cants-dataflow-test-"));
   try {
-    return analyze(options(level, cacheDir));
+    return await analyze(options(level, cacheDir, jobs));
   } finally {
     fs.rmSync(cacheDir, { recursive: true, force: true });
   }
 }
 
-const app = run(3);
+const app = await run(3);
 const pg = app.program_graphs as ProgramGraphs;
 
 const cfgOf = (sig: string): FunctionCfg => {
@@ -366,13 +367,18 @@ describe("summary and SDG gates", () => {
 // ------------------------------------------------------------------------------------------------
 
 describe("determinism and gating", () => {
-  test("two runs on identical content emit byte-identical program_graphs", () => {
-    const second = run(3);
+  test("two runs on identical content emit byte-identical program_graphs", async () => {
+    const second = await run(3);
     expect(JSON.stringify(second.program_graphs)).toBe(JSON.stringify(pg));
   });
 
-  test("-a 1 emits no program_graphs section", () => {
-    const level1 = run(1);
+  test("--jobs N (workers + wavefront) is byte-identical to --jobs 1 (the differential oracle)", async () => {
+    const parallel = await run(3, 4);
+    expect(JSON.stringify(parallel.program_graphs)).toBe(JSON.stringify(pg));
+  }, 60_000);
+
+  test("-a 1 emits no program_graphs section", async () => {
+    const level1 = await run(1);
     expect(level1.program_graphs).toBeUndefined();
     expect(JSON.stringify(level1)).not.toContain("program_graphs");
   });
@@ -410,4 +416,10 @@ describe("--graphs flag validation", () => {
     expect(r.exitCode).not.toBe(0);
     expect(r.stderr.toString()).toContain("invalid --graph-field-depth");
   });
+
+  test("--jobs must be a positive integer", () => {
+    const r = cli("-i", FIXTURE, "-a", "3", "--jobs", "0", "--no-build");
+    expect(r.exitCode).not.toBe(0);
+    expect(r.stderr.toString()).toContain("invalid --jobs");
+  });
 });
diff --git a/test/neo4j-bolt.test.ts b/test/neo4j-bolt.test.ts
index c3600c7..c82e71b 100644
--- a/test/neo4j-bolt.test.ts
+++ b/test/neo4j-bolt.test.ts
@@ -39,6 +39,7 @@ function optsFor(overrides: Partial<AnalysisOptions> = {}): AnalysisOptions {
     analysisLevel: 1,
     graphs: ["cfg", "dfg", "pdg", "sdg"],
     graphFieldDepth: 3,
+    jobs: 1,
     targetFiles: null,
     skipTests: true,
     eager: true,
@@ -88,7 +89,7 @@ containerSuite("neo4j bolt writer", () => {
   test(
     "full push materializes the whole graph + schema",
     async () => {
-      const rows = project(analyze(optsFor()), "sample-app");
+      const rows = project(await analyze(optsFor()), "sample-app");
       await boltWriter(rows, cfg, log, true);
 
       // Every projected node/edge lands (the fixture has no library deps, so endpoints all resolve).
@@ -121,7 +122,7 @@ containerSuite("neo4j bolt writer", () => {
   test(
     "re-pushing identical analysis is idempotent",
     async () => {
-      const rows = project(analyze(optsFor()), "sample-app");
+      const rows = project(await analyze(optsFor()), "sample-app");
       await boltWriter(rows, cfg, log, true);
       expect(await num("MATCH (n) RETURN count(n)")).toBe(rows.nodes.length);
       expect(await num("MATCH ()-[r]->() RETURN count(r)")).toBe(rows.edges.length);
@@ -132,7 +133,7 @@ containerSuite("neo4j bolt writer", () => {
   test(
     "a full run prunes a module whose source vanished",
     async () => {
-      const app = analyze(optsFor());
+      const app = await analyze(optsFor());
       const victim = Object.keys(app.symbol_table).sort()[0];
       delete app.symbol_table[victim];
 
diff --git a/test/neo4j-schema.test.ts b/test/neo4j-schema.test.ts
index 80613a8..cbeffb6 100644
--- a/test/neo4j-schema.test.ts
+++ b/test/neo4j-schema.test.ts
@@ -23,16 +23,17 @@ import type { AnalysisOptions } from "../src/options";
 
 const FIXTURE = path.resolve(import.meta.dir, "fixtures/sample-app");
 
-function fixtureRows() {
+async function fixtureRows() {
   const cacheDir = fs.mkdtempSync(path.join(os.tmpdir(), "cants-schema-test-"));
   const opts: AnalysisOptions = {
     input: FIXTURE, output: null, emit: "json", appName: "sample-app",
     neo4jUri: null, neo4jUser: "neo4j", neo4jPassword: "", neo4jDatabase: null,
-    analysisLevel: 1, graphs: ["cfg", "dfg", "pdg", "sdg"], graphFieldDepth: 3, targetFiles: null, skipTests: true, eager: true,
+    analysisLevel: 1, graphs: ["cfg", "dfg", "pdg", "sdg"], graphFieldDepth: 3, jobs: 1,
+    targetFiles: null, skipTests: true, eager: true,
     noBuild: true, phantoms: true, callGraphProvider: "tsc", cacheDir, verbosity: 0,
   };
   try {
-    return project(analyze(opts), "sample-app");
+    return project(await analyze(opts), "sample-app");
   } finally {
     fs.rmSync(cacheDir, { recursive: true, force: true });
   }
@@ -55,8 +56,9 @@ function specificLabel(labels: string[]): string {
   return labels.find((l) => l !== "Symbol" && !markers.has(l) && !twins.has(l)) ?? "Symbol";
 }
 
+const rows = await fixtureRows();
+
 describe("neo4j schema conformance", () => {
-  const rows = fixtureRows();
 
   test("every emitted node label + property is declared in the schema", () => {
     for (const node of rows.nodes) {
diff --git a/tsconfig.json b/tsconfig.json
index 69927ed..4c42630 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -4,7 +4,7 @@
     "module": "ESNext",
     "moduleResolution": "bundler",
     "lib": ["ES2022"],
-    "types": ["node"],
+    "types": ["node", "bun"],
     "strict": true,
     "esModuleInterop": true,
     "skipLibCheck": true,

From ff3bc677e27e9ebed5f649f00cb764801307ab14 Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Mon, 6 Jul 2026 23:59:12 -0400
Subject: [PATCH 07/32] feat: schema-v2 additive-CPG emitter + neo4j v2
 projection (WIP baseline)

Checkpoint of the in-progress schema-v2 migration (emitter in src/schema/v2,
neo4j v2 projection, L3/L4 program-graph wiring) so the #26 contract-correctness
compliance fixes (#27-#33) have a committed base to branch from.
---
 CLAUDE.md                          |  75 +++--
 README.md                          | 103 +++----
 package.json                       |   2 +-
 schema.neo4j.json                  | 357 +++++++++---------------
 src/build/neo4j/bolt.ts            |  13 +-
 src/build/neo4j/cypher.ts          |  14 +-
 src/build/neo4j/project.ts         | Bin 19808 -> 11615 bytes
 src/build/neo4j/schema.ts          | 352 ++++++------------------
 src/cli.ts                         |  38 ++-
 src/core.ts                        |   2 +-
 src/options/options.ts             |   7 +-
 src/schema/schema.ts               |  25 ++
 src/schema/v2/dataflow.ts          | Bin 0 -> 12941 bytes
 src/schema/v2/emit.ts              | 382 ++++++++++++++++++++++++++
 src/schema/v2/index.ts             |   4 +
 src/schema/v2/model.ts             | 122 +++++++++
 src/syntactic_analysis/builders.ts |  31 +++
 src/utils/serialize.ts             |  16 +-
 test/neo4j-schema.test.ts          |  42 +--
 test/schema-v2.test.ts             | 425 +++++++++++++++++++++++++++++
 test/synthesized-nodes.test.ts     |  53 ++--
 21 files changed, 1415 insertions(+), 648 deletions(-)
 create mode 100644 src/schema/v2/dataflow.ts
 create mode 100644 src/schema/v2/emit.ts
 create mode 100644 src/schema/v2/index.ts
 create mode 100644 src/schema/v2/model.ts
 create mode 100644 test/schema-v2.test.ts

diff --git a/CLAUDE.md b/CLAUDE.md
index 311b536..ce21910 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -6,12 +6,46 @@ Agent guidance for `codellm-devkit/codeanalyzer-typescript` (`cants`).
 
 `cants` is a TypeScript/JavaScript static analyzer built on the TypeScript compiler
 (via [ts-morph](https://ts-morph.com/)). It is the CLDK TypeScript backend: it emits
-the canonical CLDK `analysis.json` — a **symbol table** plus a **resolver-based call
-graph** — and can project that same analysis into a **Neo4j** property graph. It
-mirrors its [Python](https://github.com/codellm-devkit/codeanalyzer-python) and
+the **canonical schema v2** — one additive Code Property Graph — in **two projections**,
+`analysis.json` and a **Neo4j** property graph. It mirrors its
+[Python](https://github.com/codellm-devkit/codeanalyzer-python) and
 [Java](https://github.com/codellm-devkit/codeanalyzer-java) sibling analyzers, so
 output-shape parity with them is a first-class concern.
 
+## Schema v2 — the additive CPG (read this before touching output)
+
+The output is **one scale-free structure**: a containment tree of nodes (id / kind /
+`span` / children) with **typed edge overlays** (a CPG). Every classic artifact — symbol
+table, call graph, CFG, PDG, SDG — is a *projection* of that one structure, and analysis
+**levels** are how deeply it is populated (each level only ever *adds*, never rewrites):
+
+- **L1** (`-a 1`): the tree to callable depth — `application → symbol_table{module} →
+  types{}/functions{}/fields{} → callables{}` — plus `call` nodes in each callable's
+  `body{}` (with `callee` unresolved). `source` is stored once per module; every node's
+  text slices off it via `span.bytes`.
+- **L2** (`-a 2`): the `call_graph` edge list (callable→callable) at the application scope,
+  and the `callee` slot on each call node refined `null → id` (the one sanctioned mutation).
+- **L3** (`-a 3`): the rest of `body{}` (statements + `@entry`/`@exit`) and the intra-callable
+  edge lists `cfg`/`cdg`/`ddg` (reaching-definitions, `prov:["reaching-defs"]`) hung on each callable.
+- **L4** (`-a 4`): the synthetic `@formal_in:N`/`@formal_out`/`<L>/actual_in:N`/`<L>/actual_out`
+  vertices, the intra-caller `summary` edges, and the application-scope `param_in`/`param_out`
+  lists (the interprocedural SDG).
+
+**Identity is two-tier**: durable `can://<lang>/<app>/<file>/<type>/<sig>` ids at callable
+depth and above; ordinal `<callable-id>@<line>:<col>` (or `@<tag>`) below. Intra-callable
+edge lists use **bare local ids**; cross-callable lists use **fully-qualified `can://…@local`**
+ids. `L1 ⊆ L2 ⊆ L3 ⊆ L4` is a CI-checkable monotonicity gate (`test/schema-v2.test.ts`). The
+model + every decision live in `.claude/SCHEMA_DECISIONS.md` (§ "Schema v2 migration") and the
+skillset's `canonical-schema.md`.
+
+**Provider/client boundary:** the analyzer is a *pure graph provider* — it emits the graph
+substrate (CFG/PDG/SDG + `summary` edges) and stops. Slicing and taint are reachability
+*queries* over it and belong to the frontend SDK; never add a `taint_flows` section here.
+
+The v1→v2 emitter is a pure transform in **`src/schema/v2/`** (`emit.ts` reshapes the v1
+in-memory model, `dataflow.ts` maps `program_graphs` into the tree) — the parse/resolve/
+dataflow *compute* is untouched; only serialization is v2.
+
 The call graph defaults to the **union** of two backends: the TS compiler's resolver
 and the embedded [Jelly](https://github.com/cs-au-dk/jelly) flow analyzer (which
 recovers higher-order/callback edges the resolver misses). Merged edges keep a
@@ -29,19 +63,23 @@ it first; everything else is a stage it calls, in order:
    JSDoc, with precise source spans.
 3. **call graph** (`src/semantic_analysis`) — `selectProvider()` picks tsc / jelly /
    union; each provider returns edges + external (phantom) symbols.
-4. **program graphs** (`src/dataflow`) — level 3 only (`-a 3`): CFG → post-dominance/CDG →
-   access-path def-use → PDG → SCC-condensed bottom-up summaries → SDG, emitted as the
-   `program_graphs` section keyed by `(signature, node_id)`. Decisions: the "Level 3"
-   half of `.claude/SCHEMA_DECISIONS.md`; contract + staged follow-ups: issue #2.
+4. **program graphs** (`src/dataflow`) — levels 3–4 (`-a 3`/`-a 4`): CFG → post-dominance/CDG →
+   access-path def-use → PDG → SCC-condensed bottom-up summaries → SDG. This is the *compute*;
+   it produces the internal `program_graphs` model, which `src/schema/v2/dataflow.ts` then maps
+   **into the v2 tree** (`body{}` + `cfg`/`cdg`/`ddg`/`summary` per callable + `param_in`/
+   `param_out`). Decisions: `.claude/SCHEMA_DECISIONS.md`; contract + staged follow-ups: issue #2.
 5. **cache** (`src/utils/cache.ts`) — content-hash cache under `.codeanalyzer/`, so
-   re-analysis only touches what changed (level 3 also records summaries +
+   re-analysis only touches what changed (levels 3–4 also record summaries +
    dependency edges in `graphs_summaries.json`).
-6. **output** (`src/build`, `src/build/neo4j`) — `analysis.json`, a self-contained
-   `graph.cypher` snapshot, or an incremental Bolt push to a live database.
+6. **output** (`src/schema/v2`, `src/build/neo4j`) — `src/schema/v2/emit.ts` reshapes the v1
+   compute model into the schema-v2 `analysis.json`; `src/build/neo4j` projects the *same* v2
+   tree into a `graph.cypher` snapshot or an incremental Bolt push. `--emit neo4j` is always
+   **full-depth** (levels gate the JSON path only; combining `-a`/`--graphs` with it is an error).
 
-The shape of everything is the **schema** in `src/schema` (`TSApplication` is the top
-type). The Neo4j schema is versioned and enforced by a conformance test — treat it as
-a contract.
+The **output** shape is schema v2 (`src/schema/v2/model.ts`, `V2Application` the top type); the
+types in `src/schema` (`TSApplication`) are the *internal compute model* the emitter transforms.
+The Neo4j schema (`src/build/neo4j/schema.ts`, v2.0.0) is versioned and enforced by a conformance
+test — treat both as contracts and keep them in lockstep with the JSON.
 
 ## Directory map
 
@@ -52,11 +90,12 @@ a contract.
 | `src/options` | Parsed CLI options / `AnalysisOptions` |
 | `src/syntactic_analysis` | Symbol table (ts-morph traversal) |
 | `src/semantic_analysis` | Call-graph providers (tsc, jelly, union), phantoms |
-| `src/dataflow` | Level-3 program graphs: CFG, dominance/CDG, def-use, summaries, SDG, slicing |
-| `src/schema` | `TSApplication` types + signatures + `program_graphs` (the output contract) |
-| `src/build` | Dep materialization + output; `build/neo4j` = graph projection |
-| `src/utils` | fs, caching, logging, serialization, version |
-| `test` | Bun tests + `fixtures/sample-app` (levels 1–2) + `fixtures/dataflow-app` (level-3 gates) |
+| `src/dataflow` | L3/L4 program-graph **compute**: CFG, dominance/CDG, def-use, summaries, SDG |
+| `src/schema` | `TSApplication` — the internal compute model + `signatureOf` + `program_graphs` |
+| `src/schema/v2` | **the schema-v2 emitter**: `model.ts` (target shape) + `emit.ts` (tree/L1/L2) + `dataflow.ts` (L3/L4) |
+| `src/build` | Dep materialization; `build/neo4j` = the v2 graph projection (project/rows/cypher/bolt/schema) |
+| `src/utils` | fs, caching, logging, serialization (`serialize.ts` → `toV2`), version |
+| `test` | Bun tests + `fixtures/sample-app` + `fixtures/dataflow-app`; `schema-v2.test.ts` = the L1–L4 gates |
 
 ## Commands
 
diff --git a/README.md b/README.md
index 62918f0..5d96769 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@
 
 # codeanalyzer-typescript (`cants`)
 
-**A TypeScript/JavaScript static-analysis toolkit — the CLDK backend that emits a canonical symbol table and call graph, as `analysis.json` or a Neo4j property graph.**
+**A TypeScript/JavaScript static-analysis toolkit — the CLDK backend that emits the canonical schema-v2 Code Property Graph (symbol table → call graph → intraprocedural dataflow → interprocedural SDG), as `analysis.json` or a Neo4j property graph.**
 
 [![PyPI](https://img.shields.io/pypi/v/codeanalyzer-typescript?style=for-the-badge&logo=pypi&logoColor=white)](https://pypi.org/project/codeanalyzer-typescript/)
 [![Python](https://img.shields.io/pypi/pyversions/codeanalyzer-typescript?style=for-the-badge&logo=python&logoColor=white)](https://pypi.org/project/codeanalyzer-typescript/)
@@ -16,9 +16,10 @@
 ---
 
 `cants` is a static analyzer for TypeScript/JavaScript built on the TypeScript compiler (via
-[ts-morph](https://ts-morph.com/)). It produces the canonical CodeLLM-DevKit (CLDK)
-`analysis.json` — a symbol table plus a resolver-based call graph — and can project that same
-analysis into a **Neo4j property graph**. It is the TypeScript backend behind
+[ts-morph](https://ts-morph.com/)). It produces the canonical CodeLLM-DevKit (CLDK) **schema v2**
+— one additive Code Property Graph, built up level by level (symbol table → call graph →
+intraprocedural dataflow → interprocedural SDG) — as `analysis.json` and can project that same
+structure into a **Neo4j property graph**. It is the TypeScript backend behind
 [CLDK](https://github.com/codellm-devkit/python-sdk), mirroring its
 [Python](https://github.com/codellm-devkit/codeanalyzer-python) and
 [Java](https://github.com/codellm-devkit/codeanalyzer-java) siblings.
@@ -135,8 +136,8 @@ written to `analysis.json` (or `graph.cypher` for `--emit neo4j`) in that direct
 ```text
 Usage: cants [options]
 
-CLDK TypeScript analyzer — emits the canonical analysis.json (symbol table +
-resolver call graph), or a Neo4j graph.
+CLDK TypeScript analyzer — emits the canonical schema-v2 CPG (symbol table →
+call graph → dataflow → SDG) as analysis.json, or a Neo4j graph.
 
 Options:
   -i, --input <path>             project root to analyze (not required for
@@ -157,12 +158,13 @@ Options:
                                  visible in shell history / process list)
                                  (default: "neo4j", env: NEO4J_PASSWORD)
   --neo4j-database <db>          Neo4j database name (env: NEO4J_DATABASE)
-  -a, --analysis-level <n>       analysis depth: 1 = symbol table + tsc resolver
-                                 call graph + RTA (default); 2 = call graph; 3 =
-                                 + program graphs (CFG/PDG/SDG) (default: "1")
-  --graphs <list>                level-3 graph sections to emit,
-                                 comma-separated: cfg | dfg | pdg | sdg
-                                 (default: all; requires -a 3)
+  -a, --analysis-level <n>       analysis depth: 1 = symbol table (default); 2 =
+                                 + resolver call graph; 3 = + intraprocedural
+                                 dataflow (cfg/cdg/ddg); 4 = + interprocedural
+                                 SDG (param_in/param_out/summary) (default: "1")
+  --graphs <list>                dataflow sections to emit, comma-separated: cfg
+                                 | dfg | pdg (require -a 3) | sdg (requires -a
+                                 4); default: all rungs at or below the level
   --graph-field-depth <k>        access-path depth bound (k-limit) for level-3
                                  dataflow (default: "3")
   -j, --jobs <n>                 worker parallelism for level-3 graphs (default:
@@ -234,46 +236,49 @@ Options:
 
 ### `analysis.json` (default)
 
-A `TSApplication` document — the canonical CLDK contract the Python SDK parses:
+The **canonical schema v2** — one additive Code Property Graph: a containment tree of nodes
+(`id` / `kind` / `span` / children) with typed edge overlays. Analysis **levels** populate it more
+deeply; each level only ever *adds*.
 
 ```jsonc
 {
-  "symbol_table":     { /* file path → module (classes, interfaces, enums,
-                           type aliases, functions, namespaces, variables, …) */ },
-  "call_graph":       [ /* CALL_DEP edges: { source, target, type, weight,
-                           provenance, tags } keyed by callable signature */ ],
-  "external_symbols": { /* phantom stubs for call targets outside the project */ }
+  "schema_version": "2.0.0", "language": "typescript", "max_level": 4, "k_limit": 3,
+  "application": {
+    "id": "can://typescript/<app>", "kind": "application",
+    "symbol_table": {                     // L1: the tree, keyed by file path
+      "<file>": { "kind": "module", "source": "…",
+        "types":     { /* class | interface | enum | type_alias | namespace nodes */ },
+        "functions": { /* callable nodes: { id, kind, span, body{}, cfg[], cdg[], ddg[], summary[] } */ },
+        "fields":    { /* module-level bindings */ } } },
+    "call_graph": [ /* L2: { src, dst, prov, weight } — callable → callable, can:// ids */ ],
+    "param_in":   [ /* L4: actual_in → formal_in, fully-qualified can://…@local ids */ ],
+    "param_out":  [ /* L4: formal_out → actual_out */ ]
+  }
 }
 ```
 
-Caller- and callee-side identifiers come from a single signature canonicalizer, so call-graph
-`source`/`target` values byte-match the corresponding `symbol_table` / `external_symbols` keys.
+Each callable's `body{}` is keyed by local id (`line:col`, or `@entry`/`@formal_in:N`/… for
+synthetic vertices); intra-callable edge lists (`cfg`/`cdg`/`ddg`/`summary`) use those bare local
+ids, cross-callable lists use fully-qualified `can://…@local` ids. A single signature canonicalizer
+underlies every `can://` id, so call edges, dataflow edges, and tree nodes all join. The full model
+is `.claude/SCHEMA_DECISIONS.md` (§ "Schema v2 migration") and the CLDK `canonical-schema.md`.
 
-### Program graphs (`-a 3`)
+### Dataflow (`-a 3` intraprocedural, `-a 4` interprocedural)
 
-`--analysis-level 3` adds a `program_graphs` section to `analysis.json` — native, whole-program
-dependence graphs built in-process from the same ts-morph AST (no external engine), per the CLDK
-level-3 dataflow contract:
+Native dependence graphs, built in-process from the same ts-morph AST (no external engine), grown
+**into the tree** (not a separate section):
 
-```jsonc
-{
-  "program_graphs": {
-    "schema_version": "1.0.0",
-    "k_limit": 3,                    // access-path depth bound (--graph-field-depth)
-    "functions": {
-      "<signature>": {
-        "cfg": { "nodes": [...], "edges": [...] },   // exceptional control-flow graph
-        "pdg": { "edges": [...] }                    // CDG (control) + DDG (data) dependence
-      }
-    },
-    "sdg_edges": [ /* cross-function CALL / PARAM_IN / PARAM_OUT / SUMMARY edges */ ]
-  }
-}
-```
+- **`-a 3`** completes each callable's `body{}` with statement nodes and hangs the intra-callable
+  edge lists `cfg` (exceptional control flow), `cdg` (control dependence), and `ddg` (data
+  dependence via reaching-definitions, `prov:["reaching-defs"]`) on the callable.
+- **`-a 4`** adds the synthetic `@formal_in:N` / `@formal_out` / `<L>/actual_in:N` / `<L>/actual_out`
+  vertices, the intra-caller `summary` edges, and the application-scope `param_in` / `param_out`
+  lists — the whole-program System Dependence Graph.
 
-Every graph node is keyed by `(signature, node_id)` — the same signature canonicalizer as the
-symbol table and call graph — so graphs, call edges, and callables all join. `--graphs
-cfg,dfg,pdg,sdg` scopes the emitted sections (default: all).
+`-a 3` implies `-a 2`; `-a 4` implies `-a 3`. `--graphs cfg,dfg,pdg,sdg` scopes which rungs emit
+(`cfg`/`dfg`/`pdg` require `-a 3`, `sdg` requires `-a 4`). `L1 ⊆ L2 ⊆ L3 ⊆ L4` is a monotonicity
+gate. Every node is addressed by its `can://…@local` id, so dataflow edges, call edges, and tree
+nodes all join.
 
 **Substrate (locked in [issue #2](https://github.com/codellm-devkit/codeanalyzer-typescript/issues/2)):**
 the CFG and reaching-definitions are hand-built from the ts-morph AST; the call-graph oracle is
@@ -282,8 +287,9 @@ the existing provenance-merged tsc ∪ Jelly graph; aliasing is a flow-insensiti
 bottom-up over the SCC condensation of the call graph, with k-limited access paths; module
 globals ride the SDG as extra parameters. The analysis is deliberately sound-leaning and
 over-approximate; known unsoundness (dynamic `eval`, reflection/monkey-patching, npm-internal
-effects) is recorded in `.claude/SCHEMA_DECISIONS.md`. Backward slicing and taint run as queries
-over the SDG (slicing ships now inside the analyzer; the configurable taint pack is staged).
+effects) is recorded in `.claude/SCHEMA_DECISIONS.md`. The analyzer is a **pure graph provider**:
+it emits the dependence-graph substrate (CFG/PDG/SDG + `summary` edges) and stops — backward
+slicing and taint are reachability *queries* over the SDG that live in the frontend SDK, not here.
 
 **Parallelism (`-j/--jobs`).** The pipeline implements the level-3 parallel execution model:
 stage-1–4 extraction fans out per callable over a Bun worker pool (partitioned by file) and is
@@ -301,9 +307,12 @@ Levels 1/2 are unaffected: nothing in level 3 runs unless `-a 3` is requested.
 
 ### Neo4j graph
 
-`--emit neo4j` projects the same analysis into a labeled property graph (declarations keyed by
-their signature under a shared `:Symbol` label; calls, imports, inheritance, decorators, and call
-sites as relationships):
+`--emit neo4j` projects the **same v2 tree** into a labeled property graph: every node keyed by its
+`can://` id under a shared `:CanNode` merge label (+ a specific kind label), containment as
+`HAS_MODULE`/`DECLARES`/`HAS_METHOD`/`HAS_FIELD`/`HAS_BODY_NODE` edges, and the overlays (`CALLS`,
+`CFG_NEXT`, `CDG`, `DDG`, `SUMMARY`, `PARAM_IN`, `PARAM_OUT`) as typed relationships. The graph is
+**always full-depth** — analysis levels gate the JSON path only, so combining `-a`/`--graphs` with
+`--emit neo4j` is an error:
 
 - **Without `--neo4j-uri`** — writes a self-contained `graph.cypher` (constraints + indexes, a
   scoped wipe, then batched `MERGE`s). Load it with `cypher-shell < graph.cypher`.
diff --git a/package.json b/package.json
index 3fee9cb..e8bbcbd 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "codeanalyzer-typescript",
   "version": "0.5.0",
-  "description": "CLDK TypeScript analyzer — emits the canonical CLDK analysis.json (symbol table + resolver-based call graph) via ts-morph.",
+  "description": "CLDK TypeScript analyzer — emits the canonical schema v2 (additive CPG: symbol table → call graph → intraprocedural dataflow → interprocedural SDG) as analysis.json and Neo4j, via ts-morph.",
   "type": "module",
   "module": "src/index.ts",
   "bin": {
diff --git a/schema.neo4j.json b/schema.neo4j.json
index c10af05..0680b8e 100644
--- a/schema.neo4j.json
+++ b/schema.neo4j.json
@@ -1,5 +1,5 @@
 {
-  "schema_version": "1.1.0",
+  "schema_version": "2.0.0",
   "generator": "codeanalyzer-typescript",
   "marker_labels": [
     "Entrypoint"
@@ -8,39 +8,43 @@
     {
       "label": "Application",
       "mergeLabel": "Application",
-      "key": "name",
+      "key": "id",
       "properties": {
-        "name": "string",
-        "schema_version": "string"
+        "id": "string",
+        "schema_version": "string",
+        "language": "string",
+        "max_level": "integer",
+        "k_limit": "integer"
       }
     },
     {
       "label": "Module",
-      "mergeLabel": "Module",
-      "key": "file_key",
+      "mergeLabel": "CanNode",
+      "key": "id",
       "properties": {
-        "file_key": "string",
-        "module_name": "string",
+        "id": "string",
+        "kind": "string",
+        "_module": "string",
+        "name": "string",
         "is_tsx": "boolean",
         "is_declaration_file": "boolean",
         "content_hash": "string",
-        "last_modified": "integer",
-        "file_size": "integer",
-        "_module": "string"
+        "start_line": "integer",
+        "end_line": "integer"
       }
     },
     {
       "label": "Class",
-      "mergeLabel": "Symbol",
-      "key": "signature",
+      "mergeLabel": "CanNode",
+      "key": "id",
       "properties": {
+        "id": "string",
+        "kind": "string",
+        "_module": "string",
         "signature": "string",
         "name": "string",
-        "code": "string",
         "base_classes": "string[]",
         "implements_types": "string[]",
-        "type_parameter_names": "string[]",
-        "docstring": "string",
         "is_abstract": "boolean",
         "is_exported": "boolean",
         "is_ambient": "boolean",
@@ -50,218 +54,159 @@
         "detection_source": "string",
         "route_path": "string",
         "http_methods": "string[]",
-        "entrypoint_count": "integer",
-        "_module": "string"
+        "entrypoint_count": "integer"
       }
     },
     {
       "label": "Interface",
-      "mergeLabel": "Symbol",
-      "key": "signature",
+      "mergeLabel": "CanNode",
+      "key": "id",
       "properties": {
+        "id": "string",
+        "kind": "string",
+        "_module": "string",
         "signature": "string",
         "name": "string",
-        "code": "string",
         "base_classes": "string[]",
-        "type_parameter_names": "string[]",
-        "call_signatures": "string[]",
-        "index_signatures": "string[]",
-        "docstring": "string",
         "is_exported": "boolean",
         "is_ambient": "boolean",
         "start_line": "integer",
-        "end_line": "integer",
-        "_module": "string"
+        "end_line": "integer"
       }
     },
     {
       "label": "Enum",
-      "mergeLabel": "Symbol",
-      "key": "signature",
+      "mergeLabel": "CanNode",
+      "key": "id",
       "properties": {
+        "id": "string",
+        "kind": "string",
+        "_module": "string",
         "signature": "string",
         "name": "string",
-        "code": "string",
-        "member_names": "string[]",
-        "member_values": "string[]",
-        "docstring": "string",
         "is_const": "boolean",
         "is_exported": "boolean",
         "is_ambient": "boolean",
         "start_line": "integer",
-        "end_line": "integer",
-        "_module": "string"
+        "end_line": "integer"
       }
     },
     {
       "label": "TypeAlias",
-      "mergeLabel": "Symbol",
-      "key": "signature",
+      "mergeLabel": "CanNode",
+      "key": "id",
       "properties": {
+        "id": "string",
+        "kind": "string",
+        "_module": "string",
         "signature": "string",
         "name": "string",
-        "code": "string",
         "aliased_type": "string",
-        "type_parameter_names": "string[]",
-        "docstring": "string",
         "is_exported": "boolean",
         "is_ambient": "boolean",
         "start_line": "integer",
-        "end_line": "integer",
-        "_module": "string"
+        "end_line": "integer"
       }
     },
     {
       "label": "Namespace",
-      "mergeLabel": "Symbol",
-      "key": "signature",
+      "mergeLabel": "CanNode",
+      "key": "id",
       "properties": {
+        "id": "string",
+        "kind": "string",
+        "_module": "string",
         "signature": "string",
         "name": "string",
-        "docstring": "string",
         "is_exported": "boolean",
         "is_ambient": "boolean",
         "start_line": "integer",
-        "end_line": "integer",
-        "_module": "string"
+        "end_line": "integer"
       }
     },
     {
       "label": "Callable",
-      "mergeLabel": "Symbol",
-      "key": "signature",
+      "mergeLabel": "CanNode",
+      "key": "id",
       "properties": {
+        "id": "string",
+        "kind": "string",
+        "_module": "string",
         "signature": "string",
         "name": "string",
-        "path": "string",
-        "kind": "string",
         "return_type": "string",
         "cyclomatic_complexity": "integer",
-        "code": "string",
-        "code_start_line": "integer",
-        "start_line": "integer",
-        "end_line": "integer",
         "accessibility": "string",
         "accessor_kind": "string",
-        "docstring": "string",
-        "type_parameter_names": "string[]",
-        "parameters_json": "string",
-        "accessed_symbols_json": "string",
         "is_static": "boolean",
         "is_abstract": "boolean",
         "is_async": "boolean",
         "is_generator": "boolean",
-        "is_optional": "boolean",
-        "is_readonly": "boolean",
         "is_exported": "boolean",
         "is_ambient": "boolean",
         "is_implicit": "boolean",
+        "start_line": "integer",
+        "end_line": "integer",
         "framework": "string",
         "detection_source": "string",
         "route_path": "string",
         "http_methods": "string[]",
-        "entrypoint_count": "integer",
-        "_module": "string"
-      }
-    },
-    {
-      "label": "External",
-      "mergeLabel": "Symbol",
-      "key": "signature",
-      "properties": {
-        "signature": "string",
-        "name": "string",
-        "module": "string"
+        "entrypoint_count": "integer"
       }
     },
     {
-      "label": "AnonymousCallable",
-      "mergeLabel": "Symbol",
-      "key": "signature",
+      "label": "Field",
+      "mergeLabel": "CanNode",
+      "key": "id",
       "properties": {
-        "signature": "string",
+        "id": "string",
+        "kind": "string",
+        "_module": "string",
         "name": "string",
-        "path": "string",
+        "type": "string",
         "start_line": "integer",
-        "start_column": "integer",
-        "_module": "string"
-      }
-    },
-    {
-      "label": "Package",
-      "mergeLabel": "Package",
-      "key": "name",
-      "properties": {
-        "name": "string"
-      }
-    },
-    {
-      "label": "Decorator",
-      "mergeLabel": "Decorator",
-      "key": "qualified_name",
-      "properties": {
-        "qualified_name": "string",
-        "name": "string"
+        "end_line": "integer"
       }
     },
     {
-      "label": "CallSite",
-      "mergeLabel": "CallSite",
+      "label": "BodyNode",
+      "mergeLabel": "CanNode",
       "key": "id",
       "properties": {
         "id": "string",
-        "method_name": "string",
-        "receiver_expr": "string",
-        "receiver_type": "string",
-        "argument_types": "string[]",
-        "type_arguments": "string[]",
-        "return_type": "string",
-        "callee_signature": "string",
-        "is_constructor_call": "boolean",
-        "is_optional_chain": "boolean",
+        "kind": "string",
+        "_module": "string",
+        "of": "string",
+        "parent": "string",
+        "callee": "string",
         "start_line": "integer",
-        "start_column": "integer",
-        "end_line": "integer",
-        "end_column": "integer",
-        "_module": "string"
+        "end_line": "integer"
       }
     },
     {
-      "label": "Attribute",
-      "mergeLabel": "Attribute",
+      "label": "External",
+      "mergeLabel": "CanNode",
       "key": "id",
       "properties": {
         "id": "string",
+        "kind": "string",
+        "_module": "string",
         "name": "string",
-        "type": "string",
-        "initializer": "string",
-        "accessibility": "string",
-        "docstring": "string",
-        "is_static": "boolean",
-        "is_readonly": "boolean",
-        "is_optional": "boolean",
-        "is_abstract": "boolean",
-        "start_line": "integer",
-        "end_line": "integer",
-        "_module": "string"
+        "module": "string"
       }
     },
     {
-      "label": "Variable",
-      "mergeLabel": "Variable",
+      "label": "AnonymousCallable",
+      "mergeLabel": "CanNode",
       "key": "id",
       "properties": {
         "id": "string",
+        "kind": "string",
+        "_module": "string",
         "name": "string",
-        "type": "string",
-        "initializer": "string",
-        "scope": "string",
-        "declaration_kind": "string",
-        "is_readonly": "boolean",
-        "is_exported": "boolean",
+        "path": "string",
         "start_line": "integer",
-        "end_line": "integer",
-        "_module": "string"
+        "start_column": "integer"
       }
     }
   ],
@@ -281,7 +226,6 @@
       "from": [
         "Module",
         "Namespace",
-        "Class",
         "Callable"
       ],
       "to": [
@@ -306,173 +250,136 @@
       "properties": {}
     },
     {
-      "type": "HAS_ATTRIBUTE",
-      "from": [
-        "Class",
-        "Interface"
-      ],
-      "to": [
-        "Attribute"
-      ],
-      "properties": {}
-    },
-    {
-      "type": "DECLARES_VAR",
+      "type": "HAS_FIELD",
       "from": [
         "Module",
-        "Namespace",
-        "Callable"
+        "Class",
+        "Interface",
+        "Enum",
+        "Namespace"
       ],
       "to": [
-        "Variable"
+        "Field"
       ],
       "properties": {}
     },
     {
-      "type": "HAS_CALLSITE",
+      "type": "HAS_BODY_NODE",
       "from": [
-        "Callable"
+        "Callable",
+        "AnonymousCallable"
       ],
       "to": [
-        "CallSite"
+        "BodyNode"
       ],
       "properties": {}
     },
     {
       "type": "RESOLVES_TO",
       "from": [
-        "CallSite"
+        "BodyNode"
       ],
       "to": [
         "Callable",
-        "External"
+        "External",
+        "AnonymousCallable"
       ],
       "properties": {}
     },
     {
       "type": "CALLS",
       "from": [
-        "Callable"
+        "Callable",
+        "AnonymousCallable"
       ],
       "to": [
         "Callable",
-        "External"
+        "External",
+        "AnonymousCallable"
       ],
       "properties": {
         "weight": "integer",
-        "provenance": "string[]",
-        "dispatch": "string",
-        "external": "boolean",
-        "module": "string"
+        "prov": "string[]"
       }
     },
     {
-      "type": "EXTENDS",
+      "type": "CFG_NEXT",
       "from": [
-        "Class",
-        "Interface"
+        "BodyNode"
       ],
       "to": [
-        "Class",
-        "Interface"
+        "BodyNode"
       ],
-      "properties": {}
+      "properties": {
+        "kind": "string"
+      }
     },
     {
-      "type": "IMPLEMENTS",
+      "type": "CDG",
       "from": [
-        "Class"
+        "BodyNode"
       ],
       "to": [
-        "Interface"
+        "BodyNode"
       ],
       "properties": {}
     },
     {
-      "type": "IMPORTS",
+      "type": "DDG",
       "from": [
-        "Module"
+        "BodyNode"
       ],
       "to": [
-        "Module",
-        "Package"
+        "BodyNode"
       ],
       "properties": {
-        "imported_names": "string[]",
-        "import_kinds": "string[]",
-        "is_type_only": "boolean"
+        "var": "string",
+        "prov": "string[]"
       }
     },
     {
-      "type": "RE_EXPORTS",
+      "type": "SUMMARY",
       "from": [
-        "Module"
+        "BodyNode"
       ],
       "to": [
-        "Module",
-        "Package"
+        "BodyNode"
       ],
-      "properties": {}
+      "properties": {
+        "var": "string"
+      }
     },
     {
-      "type": "MEMBER_OF",
+      "type": "PARAM_IN",
       "from": [
-        "External"
+        "BodyNode"
       ],
       "to": [
-        "Package"
+        "BodyNode"
       ],
-      "properties": {}
+      "properties": {
+        "var": "string"
+      }
     },
     {
-      "type": "DECORATED_BY",
+      "type": "PARAM_OUT",
       "from": [
-        "Class",
-        "Callable",
-        "Attribute"
+        "BodyNode"
       ],
       "to": [
-        "Decorator"
+        "BodyNode"
       ],
       "properties": {
-        "positional_arguments": "string[]",
-        "keyword_arguments_json": "string",
-        "start_line": "integer",
-        "end_line": "integer"
+        "var": "string"
       }
     }
   ],
   "constraints": [
-    "CREATE CONSTRAINT application_name IF NOT EXISTS FOR (x:Application) REQUIRE x.name IS UNIQUE",
-    "CREATE CONSTRAINT module_file_key IF NOT EXISTS FOR (x:Module) REQUIRE x.file_key IS UNIQUE",
-    "CREATE CONSTRAINT symbol_signature IF NOT EXISTS FOR (x:Symbol) REQUIRE x.signature IS UNIQUE",
-    "CREATE CONSTRAINT package_name IF NOT EXISTS FOR (x:Package) REQUIRE x.name IS UNIQUE",
-    "CREATE CONSTRAINT decorator_qualified_name IF NOT EXISTS FOR (x:Decorator) REQUIRE x.qualified_name IS UNIQUE",
-    "CREATE CONSTRAINT callsite_id IF NOT EXISTS FOR (x:CallSite) REQUIRE x.id IS UNIQUE",
-    "CREATE CONSTRAINT attribute_id IF NOT EXISTS FOR (x:Attribute) REQUIRE x.id IS UNIQUE",
-    "CREATE CONSTRAINT variable_id IF NOT EXISTS FOR (x:Variable) REQUIRE x.id IS UNIQUE"
+    "CREATE CONSTRAINT application_id IF NOT EXISTS FOR (x:Application) REQUIRE x.id IS UNIQUE",
+    "CREATE CONSTRAINT cannode_id IF NOT EXISTS FOR (x:CanNode) REQUIRE x.id IS UNIQUE"
   ],
   "indexes": [
     "CREATE INDEX callable_name IF NOT EXISTS FOR (c:Callable) ON (c.name)",
-    "CREATE INDEX decorator_name IF NOT EXISTS FOR (d:Decorator) ON (d.name)",
-    "CREATE FULLTEXT INDEX code_fts IF NOT EXISTS FOR (c:Callable) ON EACH [c.code, c.docstring]"
-  ],
-  "label_twins": {
-    "Application": "TSApplication",
-    "Module": "TSModule",
-    "Class": "TSClass",
-    "Interface": "TSInterface",
-    "Enum": "TSEnum",
-    "TypeAlias": "TSTypeAlias",
-    "Namespace": "TSNamespace",
-    "Callable": "TSCallable",
-    "External": "TSExternal",
-    "AnonymousCallable": "TSAnonymousCallable",
-    "Package": "TSPackage",
-    "Decorator": "TSDecorator",
-    "CallSite": "TSCallSite",
-    "Attribute": "TSAttribute",
-    "Variable": "TSVariable",
-    "Entrypoint": "TSEntrypoint"
-  }
+    "CREATE INDEX cannode_kind IF NOT EXISTS FOR (n:CanNode) ON (n.kind)"
+  ]
 }
diff --git a/src/build/neo4j/bolt.ts b/src/build/neo4j/bolt.ts
index c8c981c..c60102a 100644
--- a/src/build/neo4j/bolt.ts
+++ b/src/build/neo4j/bolt.ts
@@ -30,7 +30,7 @@ export interface BoltConfig {
   database: string | null;
 }
 
-const DESCENDANTS = "[:DECLARES|HAS_METHOD|HAS_ATTRIBUTE|DECLARES_VAR|HAS_CALLSITE*1..]";
+const DESCENDANTS = "[:DECLARES|HAS_METHOD|HAS_FIELD|HAS_BODY_NODE*1..]";
 const BATCH = 1000;
 
 export async function boltWriter(
@@ -68,7 +68,7 @@ export async function boltWriter(
     // 2. diff content_hash.
     const dbHash = new Map<string, string | null>();
     await withSession(session, async (s) => {
-      const res = await s.run("MATCH (m:Module) RETURN m.file_key AS k, m.content_hash AS h");
+      const res = await s.run("MATCH (m:Module) RETURN m._module AS k, m.content_hash AS h");
       for (const rec of res.records) dbHash.set(rec.get("k"), rec.get("h"));
     });
     const changed = new Set<string>();
@@ -92,7 +92,7 @@ export async function boltWriter(
         await s.executeWrite(async (tx: any) => {
           await tx.run(`MATCH (x {_module: $m})-[r]->() DELETE r`, { m });
           await tx.run(
-            `MATCH (x {_module: $m}) WHERE NOT coalesce(x.signature, x.id, x.file_key) IN $keys DETACH DELETE x`,
+            `MATCH (x {_module: $m}) WHERE NOT x.id IN $keys DETACH DELETE x`,
             { m, keys },
           );
         });
@@ -112,7 +112,7 @@ export async function boltWriter(
       const present = [...byModule.keys()];
       await withSession(session, async (s) => {
         const res = await s.run(
-          `MATCH (m:Module) WHERE NOT m.file_key IN $present ` +
+          `MATCH (m:Module) WHERE NOT m._module IN $present ` +
             `OPTIONAL MATCH (m)-${DESCENDANTS}->(x) DETACH DELETE x, m RETURN count(m) AS pruned`,
           { present },
         );
@@ -189,8 +189,9 @@ function bucket<K, V>(map: Map<K, V[]>, key: K): V[] {
   return arr;
 }
 
-function hashOf(nodes: NodeRow[], fileKey: string): string | undefined {
-  const mod = nodes.find((n) => n.labels[0] === "Module" && n.value === fileKey);
+function hashOf(nodes: NodeRow[], _fileKey: string): string | undefined {
+  // Every node in `nodes` shares the same _module; the Module row (labels include "Module") carries the hash.
+  const mod = nodes.find((n) => n.labels.includes("Module"));
   const h = mod?.props.content_hash;
   return typeof h === "string" ? h : undefined;
 }
diff --git a/src/build/neo4j/cypher.ts b/src/build/neo4j/cypher.ts
index aefe6f1..a724125 100644
--- a/src/build/neo4j/cypher.ts
+++ b/src/build/neo4j/cypher.ts
@@ -13,15 +13,15 @@ import { CONSTRAINTS, INDEXES } from "./schema";
 
 const BATCH = 500;
 
-export function renderCypher(rows: GraphRows, appName: string): string {
+export function renderCypher(rows: GraphRows, appId: string): string {
   const out: string[] = [];
 
   out.push("// ── constraints & indexes ──");
   for (const stmt of CONSTRAINTS) out.push(`${stmt};`);
   for (const stmt of INDEXES) out.push(`${stmt};`);
 
-  out.push("", "// ── wipe this project's prior subgraph (externals/packages/decorators are shared) ──");
-  out.push(wipe(appName));
+  out.push("", "// ── wipe this project's prior subgraph (external targets are shared) ──");
+  out.push(wipe(appId));
 
   out.push("", "// ── nodes ──");
   for (const block of nodeStatements(rows.nodes)) out.push(block);
@@ -33,12 +33,12 @@ export function renderCypher(rows: GraphRows, appName: string): string {
   return out.join("\n");
 }
 
-function wipe(appName: string): string {
-  const name = cypherValue(appName);
+function wipe(appId: string): string {
+  const id = cypherValue(appId);
   return [
-    `MATCH (a:Application {name: ${name}})`,
+    `MATCH (a:Application {id: ${id}})`,
     "OPTIONAL MATCH (a)-[:HAS_MODULE]->(m:Module)",
-    "OPTIONAL MATCH (m)-[:DECLARES|HAS_METHOD|HAS_ATTRIBUTE|DECLARES_VAR|HAS_CALLSITE*1..]->(x)",
+    "OPTIONAL MATCH (m)-[:DECLARES|HAS_METHOD|HAS_FIELD|HAS_BODY_NODE*1..]->(x)",
     "DETACH DELETE x, m, a;",
   ].join("\n");
 }
diff --git a/src/build/neo4j/project.ts b/src/build/neo4j/project.ts
index d112d3d78100fa1bda727f11eb45019ebe6add4f..5077178bee7a57d3bbbc6a077b3c38ef76e2742e 100644
GIT binary patch
literal 11615
zcmdT~YjWF068`T~OjxM|v?VZc_LmgPQ6$>YMh}<dB%4wc3Iv8CVh~_3pd_xWs{OSG
z*xEbnJ@zO$$$s5E0}LS2dDO0})@7T6nL$raPd~oy!Qk=ZN9wVfm&H#yu7bY$<!}E~
z)l{qbqQrmFoff&8l*Nn(Ogz=IX!H81ijpL)(rdlB_v)ppO089J`R&u)`8-SGsKQH^
zeN`3es*L7STBIy)OsEbjbrWT83=>=A>7*z@nBSfi$s*J0m%sl*Rm-_HgUKR~i4a<;
z&Jx2zag=4zIMebpE|O(m=~-G;X?~@OT+>p#rpk*1d(b75AJ9zcdZU**!Bmx2MqS2H
zzBL$Jsx;Y9agkS1n$L7zsmQ3WcF#t)YM}OqdxyKH!!xCmD{VGZlqa-`zSiZESp_w;
zvuLRTVsFIjgWTk55GPlI1pmxpHjB#ThMGrZG#jP)KpMrO>eE`0B~<E+g=ePeJfu~Q
z3w1C!*<yL!lxd|)gH@LEDK=*EXl|xO1s=ymR;e_POHJHIS)Vq8MK!-z>S|Hu*!AU0
zI*wBu#U)Xv1zzL0MPMnhVKiP${If46Oyg|#XsB@RW*W_f>YvX}j<KI=$_D_pj4snC
zOaH1vNS4pB`1WakgH|zx;^~l`J06msN}xgIl@8UArD;`ev$!E{`2^#rEK?l!<wz9d
zQU!Eym_a8#Nue@0QC<Yf#H@O9P$ILB4QaxrRk73*BIW)zZKt$LVF$xo2smf)VOdg`
zT$7*%j~=D7c~Mq;OzKXxG<^e)UqZi*p>fpSvpPy`N0HhuNR6p+#Hvm$_sVHeRP_8B
zny>D~-g;p;z+W-B!S&PLwqxQ>o$Y-!JlY+7J3Ku*z$w&k*xCM6GA31@`-bd*);-k|
z`}C?T=3Wyz4i))wk!Fc5p|a&7_m~=xC1Zg{gU6yhR)j~x)0aa9<J6gYLT6$vL@aDG
zO*X~y_*6;PlBCqeK=|WjNFpYUt<>J`v3jO@dr?k2Vjbx&^#t8Pnrtakl{otT7Hoqz
zp`Pui;7(TFqW3pwb=uRG>ZM6<LtRJNLT|yw)qUSG{$i13%gvt`(AUWldhh(oW>%mH
zdxE>5Jp{9~EDIQ25>?S8D{e@)|NSpD`MGwMXZv4oS{an^V13?<b6%LpPJw*ZLCySz
z;$^<pOK&@}FLn1wDKXf3QfR8Etju?5H4S=S^!n<#y8Q6Yv3!u+e|YEU-CwG$&fpjR
z==P)gM^>a?9~|$G4tKvC9&V{qn0=XiE-Y+V5${0a#EqB@geiL4gR!YNi;O|n9{qAp
zn!|P`Q4B%%4qTf@biSCObBG^)CXF0H@DULpjo+m<59QHJo4F7<c5NQv7=Za~L_*dY
zE0MNMnQ7w&`kf_m|4diY0!Ps9W%Vi-aaEMvp(|ZsOWj_xvKQ{6xam%HN-)y5bJBGL
zv-XsGXd}kRvADU;^#;)#`rGj{BXp8jo_lIjn>L@7Sj!kEm+KqPi~}e>PK`~hgtH;i
z<a96*G(-GzaT_eTiRgusz?5-FRvVo6cAI&<iw$dDL@%TO%AO)1l~FLZEyR2o;12O)
zBlvldL)(RsPAS-Mezl0MphCoydy=tPbUVrrG%^{iA7%8-C`$nYWXwLO=g(CRJEs}<
zeX@L|C`JS#2B@_{a61_j_zBrZn1ER}%NYXds3N27_gSt^BouI9wvdTf1==T*0Bx49
zn}z4L;MglU`>6$oX)HG(MIOr#sSOTmpiDfISjHhikDy10<mhDoo5LZTnjFps@qxAM
zOdCMY;$p6YF%P;K4OJovFQC+5pq%BXEFG6XC<>kidQZ{ZkBkHi^FrAe+(%6GC8=+#
zhmsUgVu&N^NMvg0Oz!R(^K^Vp6DxOWnLE7`@i|@_%>#8`@mT3x-<vciV|NTdV&q)5
z6pd4h<pO^#J#qx1CL|pe&Wp4()h3Wyg%ANOu$&bO!=Yjv#Q?DZ9gEU=GB4o$1k^H^
z%^BR#DyAzd6R#7MS?0jr2KXr%Ip6+Hc~SgZC#zk@ZtVhVtuwJNGwhW9aA1`ID>%nO
zEjR>+0PoVS`UGUFDSIL6qXz<d{D*@T%rS>(;mh+wv@i+Yf=7CIS*FBAwwS>q(xkm2
zYtOO7tj4WciA}oE<P&%n!r+Y36}eC6(Uc)`0AQfhhPGuP=o27jXeVqY*2$to*k@3#
zILu>x&sS(VH1-Yjz99U5ZI^qyhlgj76F^F!LsQ1sqO=oJk*o+o0ixXK^lAzpr9)}a
zNO4Wi^y`#w<+3hsXcm37d%AlxIykoLrV0FzEN)k~J;Z{?!*zs+rs3{N=N^B<x}2ss
zFC+_}eDnIhv@#@Z@y<A$q<Lzl6s+K&;GQ=Br+;V#wpYqY-@|eYnZLtYlxUGoA}@)j
zfZ1w>Ob%F6Qs9$Qc2yP!5n3`p)D9qUn-k&=(ro*FU^)-O^J*0Hk7S9rHrF6KE|D?T
zV7iVHY;l6KuL~e&it3(bu5kFgMkwrxm+w0;Lm-dB5po<^uU>}ZmPdDmcNDtK_B*tl
zgCqKIGLC-FrR~sC8??J?O&)q;yOz`&ItwxKq*ahMxm6m<&{xM|d)MuQVBkgKa5R3K
z<OQ)va`j9#$o;$u$z5NNEn6&3(Osq!X7j)s2T>+bhXRS7bY!m>eBgZCj#yaE<ULus
zofC1MlTK71T&QQykhyWxBM6T?g_K4)ahy3&f>r44X02^PB2lCCz^;bEDQW(LG7ys#
zhao_wrI#!8rwUytbJ4Wc%Z}~{R|2z!ufICk|6RIM!FzF?>K%I1**AH)uGTa>wKXRu
z^L2w8Q~;se<QRek{Ik!egpOSjXHU{~ApX^c?5UH1hD;+f%&T%KFeZp8!8{kt<rah_
zkifY)y$fWS-5D3_G>>%-MFmO51!TmwMk0C#yIrMsyhrTG?oQMON(U8y!cfVD6$zg6
z@Y5}c>;@$=v#kz4dqVq;Dz1l-%M^4~rLh7|zz>iadVvVi(v|N_2iBguq<TY*^9#>e
zz+qBNDu_d_6S(shZ5P>&;WD3b^3Pz)QDTd6_BjSd=-Ow`6_Of|3sPVJn-y7&b39R3
zOJeOL;mec#??=Zc`;;e$%F$YOaW+_(77)!iXWKyWmQ7bQ2X^c19#zki!*7RYqt_>(
zL^K50)bB}#LU7sh;S81-hCxE8f&$Jvf_pDsj*f?aanON^BP^d5aPfLO;6<RRW}o+K
z@TF!TX)&<>5<9_00&f*UY!)<my}UNdY~9{a+4c6e|2s(|0$5!55R=iEhYX=%l*q0_
zYHq8x%IxuU_RZ1J?&<fxYs>HAOE?hwJBE`+_0Cx`tT4_BgPQ}kEY^4_6X~vD#Vfot
zG{w4vcYA5L3hSo5pyW(}Jdk%-D?m#8s{rLUxM+(6+WvV${+UM}I_F<?#kA-HSHQ#?
zKQMWawo%e1y*6j#07N#=nJy)46PK@1Fy&AX1QWV(klJ&f#R1(9!;sRjV1jm?b6K|Q
z`bpc#yf_#hQiNnLUHj(uh1+2tDCr|HpP-gsX}%2za6iG4L=Q@~bOmv&i$DFendvKJ
zcLo|3m1cliU9>d)_W}6p;4aW!JUH476tDfb7pHj|gD0C9bqi~tz{+5cU5K~NopK5P
zm}Sa{lXvo*-q9lYH>1kjZXw7Z3-7)ugHQ`J5{<fV$v0FZqOksz?o3-9KybuaRU;q{
zTRrG5=g;u;68x{#OimVSNqcCPr2HCs|A%BO*jOYi_!f1G^eT^Vmu4-g3hNFq*BD*E
z_lM5HSmsh38AnEsxOA>j`-Xk)mSxbM?N1@0&*qt6m=VL_HE(sNS#fib9pxm?_*<;`
z<MtJtax?~KQH)eY6r%NtH%{!C5#yb8Q+cqVEVXV8^<PcdjSJ;yHcp`|>n7V_OWipz
zs<)s`5KZu`*c`eM8|eDShukjY$ea$se(1D+)h_)4TFfZrfzHJ1bSC!A)zcYq0saxT
zW_rWedAvjnp20w4oC~SWZCc@u2{$i6(0Xm<L@UZD20AwBIL-KF3M1{8TNALVJQw9i
ztYzH`c0!{L1kh7RU6i549~4VQttxa>vOCwQY(qN&;9pCc2Zi#LMjjRM?ayj9>In^P
zr>5&TcjK1#wi-WRU4|R#WXowxcNwc0a^s-xl%5KXE0mtPR|oU98TiQs`AnCCz`kLs
zI8M}o{(uj~JuKJY$GJ6y0vL&u104kc4XGv6ee!4pL8htUXUTP~%~X)5f|g80M#`5x
zBnXBw<NV#*e=p_5sm=gX%=^F^^#!aN(zOI-qeyJr`4KcmM&m!y>C`ugG>$x^^*l!o
zQg@sqzrVLv$DD8guLb}Oi~LOv2#E3mEqi{!*YSvJ(K1X8{|2{IPzY|x!O5IHl@Bi9
zjJYCu1_hgQasKiPP8%+jSxhGBt$YU&q4e2Y)~A$ml!Y;y#6*4h!ng5hr4G)RkbKd?
zSTIezuM4OqPJFvN8z&BMFKSNQyFsv5qYA-K^=)5+-<mf`;Ls^f{N<yE&*=tpXYe`h
zBJjVBCp+8Bp?yLGmG2~~DSgipO>iN><DZp@`grg$Yy=-g(8UGcpVHSTwz@aNJ_bM1
zLO%?C7@Yq&xOh_k1mTnZhl5bx>X`5qup;NN7ER9RG-l_YUeJNaw&_4*V%syYA>oSV
zjxTAT3uw@{2sl2(lreoCBEJ{gB({g$_%!7nBC@aXtq`clJN!z!3)4xARHFDGXEW}*
z%Yi#wme)50K0T1*nevsy^YHu=)HlJ5y@IlX=-?p*GWX57(gyj03Y&DF<J?Ts80geq
zSE;wSM9h;Ob|Gw|W05BsR~1l2;+8><qC%RiMPjuKVy`O&wW1$e_XvA?HQ<|By5J2w
zV4tqe{!h67lzm7e{Z8Sr-UVb$u}??2Ct!^$5}0mI;_ciWTOYL3_i&%_MA&vmAk<eM
zeWdUkW;(yZ7i>G~leXe_@uSaLXK_M>J8Ss7gCaU0YH;Yx$me%(Y{<}Wit-Km!~(Zf
zqAPrefNw-brdX75^O46kZXOqv9?>nUH-B1H^O1biLZpQZ{O|n^Os*>kwx|_ic>7j;
z(8!@<Y@*l`x&?>iF%70g$)lK}j1m_ZJV(@}FHX*M6%akj%8#OX5a|AjfS^O4d5RA0
z9tjWqKGdZ)c|QlP#mCzYn8UE{MA+}j(x2BIvw)+Ku|K)#1y!HvEq-$P^PHb*2+|xn
zVEBSkm`2849)f7WpPj&i=rYF1E2>~f@dDR!>eA}<<+ju@s3-^{m@RM~V~Pk|&%o!O
z(_&T-PNmNiB3s?CUa2a{XmH8g#AzGp-ZEa|)3G4yx>W|osa)F~A$kZoc)$nbYOly8
zO8OYDO-{yptH_a&KcMF<e=UD@!b*zR8?^iZ&DuCTqHSxqW|wds(w7^{fFKKYVmETz
Ul8c>aJqJSRbrVMcY8sLK2gUz}o&W#<

literal 19808
zcmcg!?{eEllE2S>iV4@X3+5y!Tf3iVTRA!AZj@M(OXBA4O6Q_La7e)d0UiKKViZ-~
zr+t8{d%}H^`*rusU;u(P<!tQQjWGYZXZrv2%<$mrub-)})w0Mx=(q~{>L35}f2z9H
zYPl-#AE{3AOwEdX!3}Yg<yjI(sk$0n94(hAzAN;&Qpe}2%GJDxme;Dt@5)deSL!ZG
zZ%RTzK+9;MRiWcmQ6{%2t{0O$RaG=ewSk?c`vPFHO46w=Wc;3*tSXgcWu>F3%4aIh
z(-iYfvN?gqWKx1rs-#kSkyNG1@+pe{s`PZOF_F_;9Uq(x7|C6cRJtft5U-clz))t<
zvb@eKb)YaCLK7Eyp|dJV`wTtL$`$5K3n+B8Dl$D)SAV5to@13)Av#gN6QE2}Oi4|3
zoRlC5aFkjGVm8S<Q`4l3S0%Lp+r@X^4^NIT)k>HB0fA8ain>KWqW5p~8i)WZjS8l4
ziG>!$T1Be7jtZK@;DRZ5rLcURs(_|APxDEX?k7{MAgR{Cb22>t>req)pQcJkh+x13
zynBQo2mHLiH&B(OimIweKyVN+%BJczDiWbCkg8cyl-0g;WFlLbKv%4nd6I$p)G<<v
zsJH=rWo}q8%`U&oh(eZQ2Mox8xYbym5xRYJ#Tp3*uRG!CfIDDbM$$K4<kMBEuV}!n
z&Y~=4fnDyYGG|;KBYE9Q3F`q4oY1MRw9@xcT%~JucO6xjGRPhQ`1)sH7Vv<sZ<Bmg
zq7#W$rKdFAgJ;i@#WF7{Rjrp=Jv>vYp$&Un@tqOOx<o`bC8D+Wd1R?>>hcB2pcLL%
z9!YWNNNvljg?t?ob!Jg)a6lwMA!#~=?v+c|G{Urx(j+od_{lICn5?+%J$n?b?}gz3
z{#VA=dJ*+r*o8kB0UrM}Jij<TJKa-vNp(HCgPJNgvSSnz%&E_w5bzXiKG!o-dROF2
zh$GbNwU~iDuwj*H4=x!P%;i}OHLKLg*_*$;9gc_pF}hH%)MYQM%HE!$Kll81YAY6|
zAvS+MNWTxJ-@=q*{CyAT2M1~dskO!^)zK})Fkh0vgA76)qjh<(fB{jfY^rAoi7Z6D
z%waIZ2C-6Jy!r7DrCP415tK3}(b8$D<}iYU0*bLvX;M}P(<H7SnzLw?R%QPMi?L^f
z<2-_ui!lX=I20^_DS<Z45}iU*G}H$p*z_8@V1l5>%h6$QKTxB~_v#mKp1-JUm8N}Z
zcy*}m)wkcOODtPx3OikoJtqmAzARxGviY7G9d<+7>}KIUJc6A1o>gYH%3!-eCbP64
zS}rjQ-<#|y)RD*zl;FfPoy@Sh$s{M3Vy5prQ3;$B_Fq5=rJLyTk9u92{ujCm&L-sZ
zLKw!9W)O-y8nZj<W3U^IM#v^cPD0{oaM?Sm{a)`q1TDi%A!ugKd+I@nwv53Nvi5_P
zuBb<WKg$dFAr|4wS(0kZaF3+pJvliuKQgQ^ejQU}I(SQLO;WU<=SQ%|SSaS`qk(Z?
zRSSU9wb0TP{!K!1o<Z;Xql>ZVm#mQ06a(<r^fYV~e6REAI+!?Uyc|1(3qVSY;IWTH
zWN5(f-dOcuc?}iG7kv{PkPnA?B!%@HuwXaQT#K<`{Wuw(ydIv9&;9}x%5Gqsl}}ap
z(>+-Es*9qKaHcAn*{6&}0?K~B-ykj8Tcj1g3wreI%$dy2d8369KPZxn0ZkyJFG~Qa
z0TDqAmIWfX$iebvF38ME$ubf>34{zVR8M9qkj{O_D@O}VKxPfg$p9PVK0*k$Ucjlb
zBc6byrTPKE%Nh=_%+p&Ku}IpK&ZfqxQ)IY^K&d236LOH~Qe7vRv2)^dlR_B!-O<~(
z7ZQD`X`cN7RxQfrSZn~BwbJT$fBaKFR7dK~@VmE1=R@gQ2btG7jC!z)iV}ES=vl5a
z$U;fT1&gD%x_U`N4hJtG1A2h)@bIdy@&aNA4HL5Mr!bIdy<+&9Iv|lQdx(-WY&jd`
zBoidm%hPw*@w;S+X_c!9hpL?tSH>R`IBy|i8wzbmUC}f-wa7W{+3=!U_Sj<v6q(RJ
zk;5_;F*KFSsJe!MjYImNFoFJ+Ra8`CrXw}g#byW4c(s6Gb6upub~4df3;LrqE+XqO
zqWV{)DItQP>KGpM{%jWX1}}R?#-$re!z)F-57js7TOLtj<Dr9Z5VWqUz8a|BOX1-m
zq5@h5sfP@F^~!6kb;XJvROLZ}Q~)_)l|&VcC7DK4dA9R5N>}8Ogkb7%5Bg$_ARIaZ
z1!FTk*sv))kAB_RTD=h@E1J&>J%?IN)j*V{LIf46q0>7Grnv)*1_#LC&s<}lf;b!a
z5r&A_+LwKl(+T1POe<ntSOSTerQ;qH14BI_L?_=M@P3Tcowf-k=p}8JfF_zC+-?ay
z0{a<7Lu^h-qQ|Tn&W>8T@Crd)B8m>nd{x96gps1G3q=AjgzpjGq{BO%%&#lBS0K<K
zyp0L>(N%|4G%qP|c`&lY#Fc#-*nx;FDX#;F6Y52pfDA$xI68r!9MvGgAY04E_fQ43
zOkD6Lt05C^Flwz(*o~X`_BzH9hb3lw-~}psRwvuoB`#wRL_+)(scs*frmZK3Y$V`r
zg~Sv@B<}=`AB~8^0bO|U5QY8U^dCjCqCVJ1PuEoZP4VqNdsY)!5*31;BM^{i(x5gf
zOz2}7P6`5>0fsxyn<@%M1(vBWF$=;tU6~;GaPJu;<~C2J%qcJCn0dh)3r87Hqybc+
zoiH1F6E;~Z-WfFYJWC>$#zPcuN5uPTq!pln77gt;KZzq|!|UNlw&UQfIBhn4G;Rml
zi7IJ>XTxCv-4?BMwp#d*hbVUf)oq~F_Bqq$bBy>UDjTzQyWvg*RU1LJ9RVpFZ?pZW
zpW4b!@L3!DErBOvM<V0WFEuOeX1x=di|=m%77}jQf6Up6ZUF!q8<?8N9LCa$Y8$|p
zRxFs2ce>ce9HE5!%LrQm>oa*{MX5mSzu`&YtR_h|#Rj$HurJ~bHu6r!Ut(W@y*Y9|
za4qD&ocyYz`P>BjRqkwogb~cohTcp44KS4*^(0_tS-Kv;2<FHaWYql;{}<;YNh7-p
zJ&BfXON}`klAp3Y3oX0luD-@kaep^JmiZU>cJgjZ9a}r+IX2^3uql7QIEM-&OyGZk
zaS8GX1w&}=;{1)9#8*W~WKgdt!V(7coTIA!=gBTH6+r2=LXyD7Za!?Y6{>-^_C^Iq
zwM;zc87a5%f&!pb<~B8jPLWAP=Go-#D8?yok|pm1NGyPz@)V6NWU}zp(J;_OHo{g&
z)+-}tU_g*8Hn(bDRe7I;07>hWmSxJ=8w|aA{!rxzf|132{1^UaWB7RGcZArZtC>KE
z5HPsubL4}xy95&uNJ@rKas#oE5mB$E7S5``Cd{KYW=xXaC*9(&GK{8ES_oImG^mY%
z+BTWXnCcAiIbgx4q#U!U&7lec)Z)exW)Wg#!)Y-~VM(h&gg2ivAW|653DL@767ABB
zqi{U1(dF^UyR-Ar1!6J?BiuT}3yC<*y^z4s)3H(R%P<Vxy5A!#Er@<BiI8)iA+HhS
zwOyGE8(qCc515j6(E`kmP`%aZdtbne*1N?qMfJTEs9J<bw$mK3GU9tqtNr8e{|h6C
z9l><X0u3HW3-%W90!vCv(q`5>Qs6aqig1n5Fp474O%ZlhiaEGdjIr0wyBJFrc?R2K
z77b^I4OSUo@s_9Ol+|ssm4U%W{q`XyFnB5P@(W<xaJ=7f;08|Z63-%Kf_$O#VI+4_
zb*@wE52!LmX>`G$n{liN1Gcr$Q<v^^JD?tq*vL1;Y3O!D<`n52rSO9|buL79{)Vk?
zPEbvrvE3Zg)HodqwM+RFt{lOmk`ttW2#D$iwlI=M^t1`-c?q7-cY-i)Y(rt}1yk&U
zgW$fe-~hj>0WpRU$3^K1=X7Xy@;Az5=|K-i3&YblWLrQR>{wZvJ+vGrw?JAcuA#s}
zy&awmPuWN@Ac}~wXb%z}aGJ$JRn6fXreq>H$fMLz_{T8B_<A7NV{Jy&pvXd3*ZI_s
zO*^+A3|2C~!_oI=Z^)#!R~!+cJCW1}h~ECgoo_XwRz}nmpQw!p2PWGvC0V8m$Kjer
zqBEe6i-u)I-fk+Ptxi{*Ymd-^roLHFPK%7>*1Cq%XHqJ+1M;_rpHM3|W<#}-%2zEH
zvWj{oNQ#&hHq^`CH8%CDA!(!@R$G9lp)H%T+tL8)-R9I5xdZHfqTIocb;%u&kdxCz
zg~O8F<gQ8EWw$)YwzH8+ur&XOC}?CxM;A2q2~t4aHv~Xuz5r-+5#H<Usl4wHcCvhY
z3jB0ouOeEZ1Mq}px-lDTts;M|m7Sa{xQhM>3qGxP;!kC1hVXB6;Q%~g!EVgPg0s?J
zFo&bq+L**=h9mG_q1{{3P(W$7_P&~Y#0_{xbJr9UkXX0-B%{1*`U&uzDfCz2?C7SG
z*){b9(4=HORMN{$fE(6tOWFwlNs@QYI<cqPHRS~0PHOxqJCWO*_x5xXfbE)X;z^>v
z7xq!Usl&uL!9tYN^r#f}$eFh@q^P26KSk|SZB09VC0(?jyCPWLOS`ZUEOob&`eCZG
zd3B9*q|2Tc*&=^L2OkJ^di4dH-g_J^b#{AC`=SoFE{Fldkp>WPjAoAq<amQHiCK%g
zm7K|dMdPrB2;#-ZUYu8lis9~&B9Xnmc2I}QVNB;Xd@Bq(`+#nIeuRu59PW&FjxK*f
zd{aThCpCPL3}^3jGX|%@bo-7V(F$=^N<DFypQ~hwTPszB`(4;xQzNC|ECrE7=Ol=c
zhsWPNe}HTuqa_ECkAu1_$Bd8rRD;85KB$y-Dw)<s-Xtb5aC;dNnhV^*Vq2U{!JGuy
zPnt2+3QyXGw|N<Y53!C%LkyMhRW<{X5`*CbD6K(AbCGW|lEQiS+1sCn7vs?x$p)}>
zj3V)ZIyIQJH4=t3<UrWa-M0j^ULyCVA@HL_j)oh!;<P)?iY+eMmNp`-9fIyS?KTqi
z<^T)+6;|RRnftbcLlmBtL(pX_tn{&_0mNhY{2^kyDhap_Eyoogdta|9NRh1;N!k{(
z(50HA(dhj6_1{>K8cN>agVXWo2|C_khuxvUucPqs)F<#QnPCgrOO$+)%EwdE@mnGC
zztNYc?X10>M7OA#G`CJmNPgRGP@S}oe>ysc+BGQNK`(Ec-Ha6JHkV1j<Mu2Oz;)e>
z31OCf<Kuer0{(l2lPDzHB@u}^O~YmtWp}4cBf6tNj(%Xu=F*VOk|9JpJ3kr?-;7`X
zC#?;817L3EJ(oFbdqVdX$2btdjb_}`C2(E!lCMNY{tmbP>h9wYC9Pi0%ahsqcos}4
zZ{O@?Ql~XT2}@lP*w%DYoBgI1&XIy0UnI3h0)q|XTFr1SQ0a^=QwA56Uhe-%6*%rF
z`(I!lb;3`MP(+IHO`;`dCr+X*?ICE~joq}l3gG9s1rq1C2b2sq*<-E{`cs0w#HCPb
zly6rL$+35U$K;S*r*?ykfTDtQ)%ZFpahZtV`8CpquJ_Q5AeMIN)TokPgbaT3XM@od
zrPbXiGC=~>n!62lLn9a1g@AsBvmIxCihQDJNK4U&V2^RlVgUG9+|*S0`4VpOD`Zri
z5R_ykcWYNlSKcEaSp$s7Qre>llLu@zmi-V{j)MUAo{-3tn}tT{rg<#d3B9tPxKhRQ
z<_qPe=?I=j6LiJ(cbQaOHdC)p4{Qf}n&3J_i%A03+jdiw=33#oxh_hx)p>5T1!=-*
z41k))1eTdzm0iLv0^xRv0;iRsd$L}MU?6YQ77SEv6AUzM3PzKmKDW`m+4vD|Q>a-7
zny}_Hjb@$U6<w`s_r$4Pqf)v$v1v*WFR(2^Rv;L$cid!<LZqyKU^q#f6s5VA2p(P+
zrP;~^H`;<U?ZS9JQAUQ8_VAy{Ze-xv>_%11?uA}Vni`8{skFSqeP(E?IZTyBm{D@#
zh0{X1+qP{OccNgR*TcCkTq7NB(=Kk3O!3YK+pZGteQ>AmROf&GK(L}UtfQ)JK$Dp~
z{Wdc>;KCilj5x&wnW)EC+iLmlIygSd=&gK4^L9R?@#%afUEvI-D0nL?`I#I?9<t4G
zRMi}p3q(`4>3CEYg?@z)rK!Wdf}?x0(F)1#=A0+f=AUH>Psn51CX+DyW6Fr;?My=B
z)0srX<V#V)q*f;NGnr&kU$VR{RttS%c}QiQhDR7&mOvV@c5|DAlJ>3AjOOixLgUj3
zMaJ7p4Uyrp`}fbJl7Hb_u6z5pz3CbQJTTwtkmXA-X(T%iy`r?o>p0Ev3?PYNBj}9w
z9*+zOL}!B;Be9dGK%`3Jnsz+CStTQzUFwpwTKdv(`z<X|j9ZCiGD%W1yGDiIColMF
z2Z4}2rb7B`5i6{=DOF8{_O(6UUD;jmS9a{Ph-)S`w4yBY#qP1>3(DQ2+MVj~57Yz~
zY2nZTDafM9Hq@aZn+j8`+i`i^4vpyBwahgVQS_YD0Cr{9!@iy~9c<CH(*+i~He}ju
z(Y4ohj%RL*uHE?}Zf+<qRz|^h5>p(=&9*3`yCP3WmW@R%;dhBY+Ib*WWlEX3ywPVW
zwC|co><~Jzh?(_g*yF<+{Y*J@nEARW?F~Jk9*qj=vqk910k(aPl_7R0Eg7<m<9U>0
zTQu`5$CmM?-4<PYEra5&8Zro6?vcvJ+|}oJt5!ORIA`-t$lutl@n^D6QeLu1Vc+dG
z_T6r>uZ)qfz^(I;KMcF-IT=%SOPNADPp)%BwOk+=&<0y{?N*yiyDdt)Pjo+FC#}{3
z(@^^@ExYIoc|I=zZ#^GUR(LdLcKkbMKlqXhTVV__cMrHI^TBO=jpK@fuE#-5N_aW1
zqSZ&3<n^Hn>0{Gqc5jb6lP0kyHPVav*C{kY*Q~Ml=y`|nyM)aZrJd;GpDGZXcAfMD
zTRD0!Rx!*lzb~WC9o4SC)xB|i9VL|Dqu$L*>FZ0tX7D4eas)#_{IZO<azU;3yKbpR
zQk#^dbyo?hUk%BdA%u7<+MH1))V>-5ZhmodiHE!NcnI0u=Hq5*KKxXY$h=D8eO3)!
z=8NBXK(G}fA4V81dsP|QDx4@{BS#xJvvBh`%j;_2YoRM&t)|PmJsel^rCnN*9gB<_
zvXtIPsc52T=g4Y*Ceb(^Jd(BzotwLSkEOS0!d)+gGW3d^<{+2I`F<+zUYFR&$kA$j
z37oGOvp7PD@yiiNh6CT_H{R*#byY1-<XRe9>4L4jv5cM}WoB_rJ_vA%h%GcD3Teo=
zzEZ@%OcqqmEoT%eAuD||5VWDIF#JJ|jh~>8<qewcHf_~Q?;^*KVT>hu=2e7sjr8y*
zG*I4(>a%9A5=Y844{LTn;#ZVRqh$*n2{<U|pH4XEOj$kSkJ(ttH}g)|WVpmBV&MRd
z1&N7<c4*(-ij0}Q927YmCeLV_0EIHWeCx}Qo4VF(<kAQH21wBRuMD^KWu46h$mHbk
z0LMqG>?Xre3?y!I)+AcDtO7(X^~*0xO75o?oSacR9hlOHBg%fjfbrkpwy%Ewdw3*s
z=1=<cP3JH&%D7l27<xJXHb9TYnk$Yt<|r{6JcE=rE9*SJO^}8@KU|!h!Vc1}CSb{!
z4HM&w9Bv%T?~~9=5Ps2t!)m<kUhxkv;6a*s2|<^}#cHsZr5_1+p(ePKtEk1iv-l#%
zAjANe9rOPD6%M>)cWPgjyr4I^PD~yl-mZszAM&E{q!Pat;`OPYf%N!|hdVRqeEDMW
z;C29$Q5Qef$o<DsjVC~CH_Zab5V36}28b&x{~bS&67<3z?pIiIWfy6e;9iAdlswQ7
z-K7*Vbe9h6?tdT+<F7XfehX)z@lJzoRq!N{AS8^eq=a9Xi`kbUPG|yx(}CVN4u1EH
zr%Qy4O}BSbgs+NvKeW>4<#m9kpIzDw1v>74MohYpA(`HT3V3Hw6M`m->o%Ot?)4v^
zKWO`GrepaS|H-Kl4qiOHLTU4<B}Tq!Zg2!I$3^XH%SP)ks~}D`-@G5llXrtIQ7`$S
zd#?u@ieDzNZ{6t<+XhM&2V8X!eE6*_``JWoK=Uk5^J2lfMBL%|mdF`B9z1`TJYE6a
zqzgwq;G+wJqqNBJV>9sP?3z6xDmB04!IH2IuYw+yZSNWpx2Tyzo*r3ySAxdW?_NMf
zbJfOn4yj$FL|QNnYw%&fQM&YM_SGNXtFP$E8jquvWxkZBcLbUr@^kG9FUPsl3&#1_
UYQpqb%RDimVdDRopO4S}AF10GDgXcg

diff --git a/src/build/neo4j/schema.ts b/src/build/neo4j/schema.ts
index 76a5ce5..5cad335 100644
--- a/src/build/neo4j/schema.ts
+++ b/src/build/neo4j/schema.ts
@@ -1,26 +1,28 @@
 /**
- * The declarative Neo4j schema — the single in-repo source of truth for the graph contract: node
- * labels with their keys and typed properties, relationship types and their endpoints, and the
- * Cypher DDL (uniqueness constraints + indexes). The constraints are DERIVED from the node labels
- * (one per distinct mergeLabel/key) so a new label brings its own constraint — there is no second
- * list to keep in sync. `--emit schema` serializes all of this to a machine-readable schema.json,
- * and the conformance test (test/neo4j-schema.test.ts) asserts the real emitter never produces a
- * label / relationship / property that isn't declared here — so this file cannot silently drift
- * from project.ts.
+ * The declarative Neo4j schema (schema v2) — the single in-repo source of truth for the graph
+ * contract: node labels with their keys and typed properties, relationship types and their
+ * endpoints, and the Cypher DDL (uniqueness constraints + indexes). Constraints are DERIVED from
+ * the node labels (one per distinct mergeLabel/key). `--emit schema` serializes all of this to
+ * schema.neo4j.json, and the conformance test (test/neo4j-schema.test.ts) asserts the emitter
+ * never produces an undeclared label / relationship / property.
  *
- * SCHEMA_VERSION is the contract version: bump MAJOR on a breaking change (renamed/removed label,
- * relationship or key), MINOR on an additive change (new label/rel/property). It is stamped onto
- * the :Application node of every emitted graph so any consumer can detect a producer/consumer
- * mismatch at runtime.
+ * Schema v2 mirrors the additive-CPG JSON (canonical-schema.md): every tree/body node is a graph
+ * node keyed on its `can://` id under the shared MERGE label `CanNode` (one uniqueness constraint,
+ * uniform edge endpoints), carrying a specific kind label; containment renders as HAS_x / DECLARES
+ * edges and every typed overlay (call_graph, cfg/cdg/ddg/summary, param_in/param_out) as a typed
+ * relationship. TypeScript uses UNPREFIXED relationship names.
+ *
+ * SCHEMA_VERSION: MAJOR on a breaking change (renamed/removed label, relationship or key), MINOR
+ * on additive. v2 is a MAJOR bump from v1 (keys moved signature→can:// id; labels reshaped).
  */
-export const SCHEMA_VERSION = "1.1.0";
+export const SCHEMA_VERSION = "2.0.0";
 
 export type PropType = "string" | "integer" | "float" | "boolean" | "string[]" | "integer[]";
 
 export interface NodeLabel {
   /** The specific label (also the key in NODE_LABELS). */
   label: string;
-  /** The label the uniqueness constraint / MERGE is on (`Symbol` for signature-keyed nodes). */
+  /** The label the uniqueness constraint / MERGE is on (`CanNode` for can://-id-keyed nodes). */
   mergeLabel: string;
   key: string;
   properties: Record<string, PropType>;
@@ -36,32 +38,8 @@ export interface RelType {
 /** Labels layered onto a node in addition to its primary/specific label. */
 export const MARKER_LABELS = ["Entrypoint"] as const;
 
-/**
- * Language-namespace twins (schema 1.1.0, additive): every specific and marker label is also
- * stamped as `TS<Label>` so a shared multi-language database can attribute TS nodes (epic #64,
- * issue #65). The shared merge label `Symbol` deliberately has NO twin — MERGE targets, keys and
- * constraints are unchanged. The bare labels drop (and rel types gain `TS_`) in schema 2.0.0.
- */
-export const TS_PREFIX = "TS";
-
-/** The TS-prefixed twin of a specific or marker label. */
-export const twinOf = (label: string): string => `${TS_PREFIX}${label}`;
-
-/**
- * Expand a projection label set with its twins: order preserved, `Symbol` skipped, idempotent.
- * Any label already starting with `TS` is treated as a twin and never re-prefixed — so no bare
- * label may legitimately begin with `TS`.
- */
-export function withTwins(labels: string[]): string[] {
-  const out = [...labels];
-  for (const l of labels) {
-    if (l === "Symbol" || l.startsWith(TS_PREFIX)) continue;
-    const t = twinOf(l);
-    if (!out.includes(t)) out.push(t);
-  }
-  return out;
-}
-
+/** The shared MERGE label for every can://-id-keyed node (one constraint; uniform edge endpoints). */
+const CAN = "CanNode";
 const SPAN = { start_line: "integer", end_line: "integer" } as const;
 const ENTRYPOINT = {
   framework: "string",
@@ -70,276 +48,112 @@ const ENTRYPOINT = {
   http_methods: "string[]",
   entrypoint_count: "integer",
 } as const;
+/** Every can://-keyed node carries these. */
+const COMMON = { id: "string", kind: "string", _module: "string" } as const;
 
 export const NODE_LABELS: NodeLabel[] = [
   {
     label: "Application",
     mergeLabel: "Application",
-    key: "name",
-    properties: { name: "string", schema_version: "string" },
+    key: "id",
+    properties: { id: "string", schema_version: "string", language: "string", max_level: "integer", k_limit: "integer" },
   },
   {
     label: "Module",
-    mergeLabel: "Module",
-    key: "file_key",
-    properties: {
-      file_key: "string",
-      module_name: "string",
-      is_tsx: "boolean",
-      is_declaration_file: "boolean",
-      content_hash: "string",
-      last_modified: "integer",
-      file_size: "integer",
-      _module: "string",
-    },
+    mergeLabel: CAN,
+    key: "id",
+    properties: { ...COMMON, name: "string", is_tsx: "boolean", is_declaration_file: "boolean", content_hash: "string", ...SPAN },
   },
   {
     label: "Class",
-    mergeLabel: "Symbol",
-    key: "signature",
+    mergeLabel: CAN,
+    key: "id",
     properties: {
-      signature: "string",
-      name: "string",
-      code: "string",
-      base_classes: "string[]",
-      implements_types: "string[]",
-      type_parameter_names: "string[]",
-      docstring: "string",
-      is_abstract: "boolean",
-      is_exported: "boolean",
-      is_ambient: "boolean",
-      ...SPAN,
-      ...ENTRYPOINT,
-      _module: "string",
+      ...COMMON, signature: "string", name: "string", base_classes: "string[]", implements_types: "string[]",
+      is_abstract: "boolean", is_exported: "boolean", is_ambient: "boolean", ...SPAN, ...ENTRYPOINT,
     },
   },
   {
     label: "Interface",
-    mergeLabel: "Symbol",
-    key: "signature",
-    properties: {
-      signature: "string",
-      name: "string",
-      code: "string",
-      base_classes: "string[]",
-      type_parameter_names: "string[]",
-      call_signatures: "string[]",
-      index_signatures: "string[]",
-      docstring: "string",
-      is_exported: "boolean",
-      is_ambient: "boolean",
-      ...SPAN,
-      _module: "string",
-    },
+    mergeLabel: CAN,
+    key: "id",
+    properties: { ...COMMON, signature: "string", name: "string", base_classes: "string[]", is_exported: "boolean", is_ambient: "boolean", ...SPAN },
   },
   {
     label: "Enum",
-    mergeLabel: "Symbol",
-    key: "signature",
-    properties: {
-      signature: "string",
-      name: "string",
-      code: "string",
-      member_names: "string[]",
-      member_values: "string[]",
-      docstring: "string",
-      is_const: "boolean",
-      is_exported: "boolean",
-      is_ambient: "boolean",
-      ...SPAN,
-      _module: "string",
-    },
+    mergeLabel: CAN,
+    key: "id",
+    properties: { ...COMMON, signature: "string", name: "string", is_const: "boolean", is_exported: "boolean", is_ambient: "boolean", ...SPAN },
   },
   {
     label: "TypeAlias",
-    mergeLabel: "Symbol",
-    key: "signature",
-    properties: {
-      signature: "string",
-      name: "string",
-      code: "string",
-      aliased_type: "string",
-      type_parameter_names: "string[]",
-      docstring: "string",
-      is_exported: "boolean",
-      is_ambient: "boolean",
-      ...SPAN,
-      _module: "string",
-    },
+    mergeLabel: CAN,
+    key: "id",
+    properties: { ...COMMON, signature: "string", name: "string", aliased_type: "string", is_exported: "boolean", is_ambient: "boolean", ...SPAN },
   },
   {
     label: "Namespace",
-    mergeLabel: "Symbol",
-    key: "signature",
-    properties: {
-      signature: "string",
-      name: "string",
-      docstring: "string",
-      is_exported: "boolean",
-      is_ambient: "boolean",
-      ...SPAN,
-      _module: "string",
-    },
+    mergeLabel: CAN,
+    key: "id",
+    properties: { ...COMMON, signature: "string", name: "string", is_exported: "boolean", is_ambient: "boolean", ...SPAN },
   },
   {
     label: "Callable",
-    mergeLabel: "Symbol",
-    key: "signature",
-    properties: {
-      signature: "string",
-      name: "string",
-      path: "string",
-      kind: "string",
-      return_type: "string",
-      cyclomatic_complexity: "integer",
-      code: "string",
-      code_start_line: "integer",
-      ...SPAN,
-      accessibility: "string",
-      accessor_kind: "string",
-      docstring: "string",
-      type_parameter_names: "string[]",
-      parameters_json: "string",
-      accessed_symbols_json: "string",
-      is_static: "boolean",
-      is_abstract: "boolean",
-      is_async: "boolean",
-      is_generator: "boolean",
-      is_optional: "boolean",
-      is_readonly: "boolean",
-      is_exported: "boolean",
-      is_ambient: "boolean",
-      is_implicit: "boolean",
-      ...ENTRYPOINT,
-      _module: "string",
-    },
-  },
-  {
-    label: "External",
-    mergeLabel: "Symbol",
-    key: "signature",
-    properties: { signature: "string", name: "string", module: "string" },
-  },
-  {
-    // A first-party anonymous callback Jelly resolves as a call endpoint but the symbol table never
-    // names. Thin (no code/params) — the signature carries identity; DECLARES links it to its host.
-    label: "AnonymousCallable",
-    mergeLabel: "Symbol",
-    key: "signature",
-    properties: {
-      signature: "string",
-      name: "string",
-      path: "string",
-      start_line: "integer",
-      start_column: "integer",
-      _module: "string",
-    },
-  },
-  { label: "Package", mergeLabel: "Package", key: "name", properties: { name: "string" } },
-  {
-    label: "Decorator",
-    mergeLabel: "Decorator",
-    key: "qualified_name",
-    properties: { qualified_name: "string", name: "string" },
-  },
-  {
-    label: "CallSite",
-    mergeLabel: "CallSite",
+    mergeLabel: CAN,
     key: "id",
     properties: {
-      id: "string",
-      method_name: "string",
-      receiver_expr: "string",
-      receiver_type: "string",
-      argument_types: "string[]",
-      type_arguments: "string[]",
-      return_type: "string",
-      callee_signature: "string",
-      is_constructor_call: "boolean",
-      is_optional_chain: "boolean",
-      start_line: "integer",
-      start_column: "integer",
-      end_line: "integer",
-      end_column: "integer",
-      _module: "string",
+      ...COMMON, signature: "string", name: "string", return_type: "string", cyclomatic_complexity: "integer",
+      accessibility: "string", accessor_kind: "string", is_static: "boolean", is_abstract: "boolean",
+      is_async: "boolean", is_generator: "boolean", is_exported: "boolean", is_ambient: "boolean", is_implicit: "boolean",
+      ...SPAN, ...ENTRYPOINT,
     },
   },
+  { label: "Field", mergeLabel: CAN, key: "id", properties: { ...COMMON, name: "string", type: "string", ...SPAN } },
   {
-    label: "Attribute",
-    mergeLabel: "Attribute",
+    // A statement / synthetic vertex inside a callable body (kind = statement|call|entry|exit|
+    // formal_in|formal_out|actual_in|actual_out). `callee` on call nodes; `of`/`parent` on synthetics.
+    label: "BodyNode",
+    mergeLabel: CAN,
     key: "id",
-    properties: {
-      id: "string",
-      name: "string",
-      type: "string",
-      initializer: "string",
-      accessibility: "string",
-      docstring: "string",
-      is_static: "boolean",
-      is_readonly: "boolean",
-      is_optional: "boolean",
-      is_abstract: "boolean",
-      ...SPAN,
-      _module: "string",
-    },
+    properties: { ...COMMON, of: "string", parent: "string", callee: "string", ...SPAN },
   },
+  { label: "External", mergeLabel: CAN, key: "id", properties: { ...COMMON, name: "string", module: "string" } },
   {
-    label: "Variable",
-    mergeLabel: "Variable",
+    label: "AnonymousCallable",
+    mergeLabel: CAN,
     key: "id",
-    properties: {
-      id: "string",
-      name: "string",
-      type: "string",
-      initializer: "string",
-      scope: "string",
-      declaration_kind: "string",
-      is_readonly: "boolean",
-      is_exported: "boolean",
-      ...SPAN,
-      _module: "string",
-    },
+    properties: { ...COMMON, name: "string", path: "string", start_line: "integer", start_column: "integer" },
   },
 ];
 
-const DECL_TARGETS = ["Class", "Interface", "Enum", "TypeAlias", "Namespace", "Callable"];
-
 export const REL_TYPES: RelType[] = [
   { type: "HAS_MODULE", from: ["Application"], to: ["Module"], properties: {} },
-  { type: "DECLARES", from: ["Module", "Namespace", "Class", "Callable"], to: DECL_TARGETS, properties: {} },
-  { type: "HAS_METHOD", from: ["Class", "Interface"], to: ["Callable"], properties: {} },
-  { type: "HAS_ATTRIBUTE", from: ["Class", "Interface"], to: ["Attribute"], properties: {} },
-  { type: "DECLARES_VAR", from: ["Module", "Namespace", "Callable"], to: ["Variable"], properties: {} },
-  { type: "HAS_CALLSITE", from: ["Callable"], to: ["CallSite"], properties: {} },
-  { type: "RESOLVES_TO", from: ["CallSite"], to: ["Callable", "External"], properties: {} },
-  {
-    type: "CALLS",
-    from: ["Callable"],
-    to: ["Callable", "External"],
-    properties: { weight: "integer", provenance: "string[]", dispatch: "string", external: "boolean", module: "string" },
-  },
-  { type: "EXTENDS", from: ["Class", "Interface"], to: ["Class", "Interface"], properties: {} },
-  { type: "IMPLEMENTS", from: ["Class"], to: ["Interface"], properties: {} },
   {
-    type: "IMPORTS",
-    from: ["Module"],
-    to: ["Module", "Package"],
-    properties: { imported_names: "string[]", import_kinds: "string[]", is_type_only: "boolean" },
+    type: "DECLARES",
+    from: ["Module", "Namespace", "Callable"],
+    to: ["Class", "Interface", "Enum", "TypeAlias", "Namespace", "Callable"],
+    properties: {},
   },
-  { type: "RE_EXPORTS", from: ["Module"], to: ["Module", "Package"], properties: {} },
-  { type: "MEMBER_OF", from: ["External"], to: ["Package"], properties: {} },
+  { type: "HAS_METHOD", from: ["Class", "Interface"], to: ["Callable"], properties: {} },
+  { type: "HAS_FIELD", from: ["Module", "Class", "Interface", "Enum", "Namespace"], to: ["Field"], properties: {} },
+  { type: "HAS_BODY_NODE", from: ["Callable", "AnonymousCallable"], to: ["BodyNode"], properties: {} },
+  { type: "RESOLVES_TO", from: ["BodyNode"], to: ["Callable", "External", "AnonymousCallable"], properties: {} },
   {
-    type: "DECORATED_BY",
-    from: ["Class", "Callable", "Attribute"],
-    to: ["Decorator"],
-    properties: { positional_arguments: "string[]", keyword_arguments_json: "string", start_line: "integer", end_line: "integer" },
-  },
+    type: "CALLS",
+    from: ["Callable", "AnonymousCallable"],
+    to: ["Callable", "External", "AnonymousCallable"],
+    properties: { weight: "integer", prov: "string[]" },
+  },
+  { type: "CFG_NEXT", from: ["BodyNode"], to: ["BodyNode"], properties: { kind: "string" } },
+  { type: "CDG", from: ["BodyNode"], to: ["BodyNode"], properties: {} },
+  { type: "DDG", from: ["BodyNode"], to: ["BodyNode"], properties: { var: "string", prov: "string[]" } },
+  { type: "SUMMARY", from: ["BodyNode"], to: ["BodyNode"], properties: { var: "string" } },
+  { type: "PARAM_IN", from: ["BodyNode"], to: ["BodyNode"], properties: { var: "string" } },
+  { type: "PARAM_OUT", from: ["BodyNode"], to: ["BodyNode"], properties: { var: "string" } },
 ];
 
 // ----------------------------------------------------------------------------------------------
-// Cypher DDL — shared by both writers, run BEFORE any load so MERGE uses an index seek (not a label
-// scan) and the identity invariant is enforced by the database. Every statement is idempotent
-// (`IF NOT EXISTS`, which Neo4j matches on schema+type, so renames never duplicate a constraint).
+// Cypher DDL — run BEFORE any load so MERGE uses an index seek. Idempotent (`IF NOT EXISTS`).
 // ----------------------------------------------------------------------------------------------
 
 /** One uniqueness constraint per distinct (mergeLabel, key) in NODE_LABELS — derived, never drifts. */
@@ -363,8 +177,7 @@ export const CONSTRAINTS: readonly string[] = uniquenessConstraints();
 /** Curated performance indexes (not 1:1 with labels, so declared explicitly). */
 export const INDEXES: readonly string[] = [
   "CREATE INDEX callable_name IF NOT EXISTS FOR (c:Callable) ON (c.name)",
-  "CREATE INDEX decorator_name IF NOT EXISTS FOR (d:Decorator) ON (d.name)",
-  "CREATE FULLTEXT INDEX code_fts IF NOT EXISTS FOR (c:Callable) ON EACH [c.code, c.docstring]",
+  "CREATE INDEX cannode_kind IF NOT EXISTS FOR (n:CanNode) ON (n.kind)",
 ];
 
 export interface SchemaDocument {
@@ -375,16 +188,6 @@ export interface SchemaDocument {
   relationship_types: RelType[];
   constraints: readonly string[];
   indexes: readonly string[];
-  /** Specific/marker label → its TS-prefixed twin (both are present on every emitted node). */
-  label_twins: Record<string, string>;
-}
-
-/** One twin per specific label + per marker label — derived from the catalogs, never drifts. */
-function labelTwins(): Record<string, string> {
-  const out: Record<string, string> = {};
-  for (const n of NODE_LABELS) out[n.label] = twinOf(n.label);
-  for (const m of MARKER_LABELS) out[m] = twinOf(m);
-  return out;
 }
 
 /** Build the full machine-readable schema document emitted by `--emit schema`. */
@@ -397,6 +200,5 @@ export function buildSchemaDocument(): SchemaDocument {
     relationship_types: REL_TYPES,
     constraints: CONSTRAINTS,
     indexes: INDEXES,
-    label_twins: labelTwins(),
   };
 }
diff --git a/src/cli.ts b/src/cli.ts
index 261049f..c2bdb46 100644
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -12,7 +12,7 @@ export function buildProgram(): Command {
   const program = new Command();
   program
     .name("cants")
-    .description("CLDK TypeScript analyzer — emits the canonical analysis.json (symbol table + resolver call graph), or a Neo4j graph.")
+    .description("CLDK TypeScript analyzer — emits the canonical schema-v2 CPG (symbol table → call graph → dataflow → SDG) as analysis.json, or a Neo4j graph.")
     .option("-i, --input <path>", "project root to analyze (not required for --emit schema)")
     .option("-o, --output <dir>", "output directory (omit ⇒ compact output to stdout)")
     .option("--emit <target>", "output target: json (analysis.json, default) | neo4j (graph.cypher or live push) | schema (the Neo4j schema.json contract)", "json")
@@ -38,12 +38,12 @@ export function buildProgram(): Command {
     .addOption(new Option("--neo4j-database <db>", "Neo4j database name").env("NEO4J_DATABASE"))
     .option(
       "-a, --analysis-level <n>",
-      "analysis depth: 1 = symbol table + tsc resolver call graph + RTA (default); 2 = call graph; 3 = + program graphs (CFG/PDG/SDG)",
+      "analysis depth: 1 = symbol table (default); 2 = + resolver call graph; 3 = + intraprocedural dataflow (cfg/cdg/ddg); 4 = + interprocedural SDG (param_in/param_out/summary)",
       "1",
     )
     .option(
       "--graphs <list>",
-      "level-3 graph sections to emit, comma-separated: cfg | dfg | pdg | sdg (default: all; requires -a 3)",
+      "dataflow sections to emit, comma-separated: cfg | dfg | pdg (require -a 3) | sdg (requires -a 4); default: all rungs at or below the level",
     )
     .option("--graph-field-depth <k>", "access-path depth bound (k-limit) for level-3 dataflow", "3")
     .option(
@@ -76,15 +76,33 @@ export function parseArgs(argv: string[]): AnalysisOptions {
   const o = program.opts();
 
   const levelStr = String(o.analysisLevel);
-  if (!["1", "2", "3"].includes(levelStr)) {
-    program.error(`error: invalid --analysis-level '${levelStr}' (expected 1, 2, or 3)`);
+  if (!["1", "2", "3", "4"].includes(levelStr)) {
+    program.error(`error: invalid --analysis-level '${levelStr}' (expected 1, 2, 3, or 4)`);
   }
-  const level = Number(levelStr) as 1 | 2 | 3;
+  let level = Number(levelStr) as 1 | 2 | 3 | 4;
 
-  // --graphs: strict validation (never a silent fallback), and only meaningful at -a 3.
-  let graphs: GraphSelector[] = [...ALL_GRAPHS];
+  // --emit target (needed early: the graph is always full-depth, so -a/--graphs are forbidden with it).
+  // Strict validation — an unrecognized value must error, never silently fall back to json.
+  const emitRaw = String(o.emit ?? "json");
+  if (!["json", "neo4j", "schema"].includes(emitRaw)) {
+    program.error(`error: invalid --emit '${emitRaw}' (expected: json, neo4j, schema)`);
+  }
+  const emit = emitRaw as EmitTarget;
+  if (emit === "neo4j") {
+    if (levelStr !== "1") {
+      program.error("error: --analysis-level does not apply to --emit neo4j; the graph is always projected at full depth");
+    }
+    if (o.graphs !== undefined) {
+      program.error("error: --graphs does not apply to --emit neo4j; the graph is always projected at full depth");
+    }
+    level = 4; // force max implemented depth so the projected graph is the full CPG
+  }
+
+  // --graphs: strict validation (never a silent fallback). Default = all rungs at or below the level;
+  // cfg/dfg/pdg require -a 3, sdg requires -a 4.
+  let graphs: GraphSelector[] = level >= 4 ? [...ALL_GRAPHS] : level === 3 ? ["cfg", "dfg", "pdg"] : [];
   if (o.graphs !== undefined) {
-    if (level !== 3) program.error("error: --graphs requires --analysis-level 3");
+    if (level < 3) program.error("error: --graphs requires --analysis-level 3 or 4");
     const requested = String(o.graphs)
       .split(",")
       .map((g) => g.trim())
@@ -94,6 +112,7 @@ export function parseArgs(argv: string[]): AnalysisOptions {
       if (!(ALL_GRAPHS as string[]).includes(g)) {
         program.error(`error: unknown --graphs value '${g}' (expected: cfg, dfg, pdg, sdg)`);
       }
+      if (g === "sdg" && level < 4) program.error("error: --graphs sdg requires --analysis-level 4");
     }
     graphs = [...new Set(requested)] as GraphSelector[];
   }
@@ -114,7 +133,6 @@ export function parseArgs(argv: string[]): AnalysisOptions {
     }
     jobs = j;
   }
-  const emit: EmitTarget = o.emit === "neo4j" ? "neo4j" : o.emit === "schema" ? "schema" : "json";
   // --emit schema is a static artifact and needs no project; every other target requires -i.
   if (emit !== "schema" && !o.input) program.error("required option '-i, --input <path>' not specified");
   const targets: string[] | null =
diff --git a/src/core.ts b/src/core.ts
index f29861f..5b67226 100644
--- a/src/core.ts
+++ b/src/core.ts
@@ -26,7 +26,7 @@ export async function analyze(opts: AnalysisOptions): Promise<TSApplication> {
   // Level 3: post stage-1–4 graph extraction to the worker pool BEFORE the call-graph solve —
   // extraction doesn't need callee resolution, so the two run concurrently (the contract's
   // "points-to solve runs concurrently with stages 1–4") and join in buildProgramGraphs.
-  const extraction = opts.analysisLevel === 3 ? startExtraction(project, symbol_table, mat.tsConfigFilePath, opts, log) : null;
+  const extraction = opts.analysisLevel >= 3 ? startExtraction(project, symbol_table, mat.tsConfigFilePath, opts, log) : null;
 
   // Call graph via the selected provider (union of tsc+jelly by default; --tsc-only / jelly opt-in).
   const provider = selectProvider(opts.callGraphProvider);
diff --git a/src/options/options.ts b/src/options/options.ts
index fe909fd..80d10d8 100644
--- a/src/options/options.ts
+++ b/src/options/options.ts
@@ -19,10 +19,11 @@ export interface AnalysisOptions {
   neo4jPassword: string;
   neo4jDatabase: string | null;
   /**
-   * Analysis depth requested by the caller (1 = symbol table + call graph [default];
-   * 2 = call graph; 3 = + native program graphs — CFG/PDG/SDG in `program_graphs`).
+   * Analysis depth requested by the caller (schema v2): 1 = symbol table (+ call sites);
+   * 2 = + resolver call graph; 3 = + intraprocedural dataflow (cfg/cdg/ddg in the tree);
+   * 4 = + interprocedural SDG (param_in/param_out/summary + synthetic vertices).
    */
-  analysisLevel: 1 | 2 | 3;
+  analysisLevel: 1 | 2 | 3 | 4;
   /** Which level-3 graph sections to emit (`--graphs`); only consulted at level 3. */
   graphs: GraphSelector[];
   /** k-limit for access-path depth in the level-3 dataflow (`--graph-field-depth`, default 3). */
diff --git a/src/schema/schema.ts b/src/schema/schema.ts
index 4c75710..31eb646 100644
--- a/src/schema/schema.ts
+++ b/src/schema/schema.ts
@@ -13,6 +13,19 @@
  * co-evolved with this file.
  */
 
+// ----------------------------------------------------------------------------------------------
+// Span (schema-v2) — the one universal attribute. `bytes` are char offsets into the owning
+// module's `source` blob, so `source.slice(bytes[0], bytes[1])` reproduces the node's text
+// (what the per-node `code` field used to hold). `start`/`end` are [line, column], 1-based, for
+// display and addressing. Captured on every container node during the AST walk (builders.ts).
+// ----------------------------------------------------------------------------------------------
+
+export interface TSSpan {
+  start: [number, number]; // [line, column], 1-based
+  end: [number, number]; // [line, column], 1-based
+  bytes: [number, number]; // [startOffset, endOffset], char offsets into module.source
+}
+
 // ----------------------------------------------------------------------------------------------
 // Leaf models
 // ----------------------------------------------------------------------------------------------
@@ -62,6 +75,7 @@ export interface TSSymbol {
 }
 
 export interface TSVariableDeclaration {
+  span?: TSSpan; // schema-v2 precise span
   name: string;
   type: string | null;
   initializer: string | null;
@@ -122,6 +136,7 @@ export interface TSCallsite {
   start_column: number;
   end_line: number;
   end_column: number;
+  bytes?: [number, number]; // schema-v2: char offsets [start, end] into module.source
 }
 
 // ----------------------------------------------------------------------------------------------
@@ -146,6 +161,7 @@ export interface TSOverloadSignature {
 }
 
 export interface TSCallable {
+  span?: TSSpan; // schema-v2 precise span (line/col + char offsets into module.source)
   name: string;
   path: string; // file path of the declaration
   signature: string; // e.g. src/user.UserService.getUser — the edge id
@@ -186,6 +202,7 @@ export interface TSCallable {
 // ----------------------------------------------------------------------------------------------
 
 export interface TSClassAttribute {
+  span?: TSSpan; // schema-v2 precise span
   name: string;
   type: string | null;
   comments: TSComment[];
@@ -205,6 +222,7 @@ export interface TSClassAttribute {
 // ----------------------------------------------------------------------------------------------
 
 export interface TSClass {
+  span?: TSSpan; // schema-v2 precise span
   name: string;
   signature: string; // e.g. src/user.UserService
   comments: TSComment[];
@@ -229,6 +247,7 @@ export interface TSClass {
 // ----------------------------------------------------------------------------------------------
 
 export interface TSInterface {
+  span?: TSSpan; // schema-v2 precise span
   name: string;
   signature: string;
   comments: TSComment[];
@@ -250,6 +269,7 @@ export interface TSInterface {
 // ----------------------------------------------------------------------------------------------
 
 export interface TSEnumMember {
+  span?: TSSpan; // schema-v2 precise span
   name: string;
   value: string | null; // initializer text or computed const value
   start_line: number;
@@ -257,6 +277,7 @@ export interface TSEnumMember {
 }
 
 export interface TSEnum {
+  span?: TSSpan; // schema-v2 precise span
   name: string;
   signature: string;
   comments: TSComment[];
@@ -274,6 +295,7 @@ export interface TSEnum {
 // ----------------------------------------------------------------------------------------------
 
 export interface TSTypeAlias {
+  span?: TSSpan; // schema-v2 precise span
   name: string;
   signature: string;
   comments: TSComment[];
@@ -291,6 +313,7 @@ export interface TSTypeAlias {
 // ----------------------------------------------------------------------------------------------
 
 export interface TSNamespace {
+  span?: TSSpan; // schema-v2 precise span
   name: string;
   signature: string;
   comments: TSComment[];
@@ -312,6 +335,8 @@ export interface TSNamespace {
 // ----------------------------------------------------------------------------------------------
 
 export interface TSModule {
+  span?: TSSpan; // schema-v2 precise span (whole file)
+  source?: string | null; // schema-v2: full file text; every node's text slices off this
   file_path: string;
   module_name: string; // the file key minus extension (== signature prefix)
   imports: TSImport[];
diff --git a/src/schema/v2/dataflow.ts b/src/schema/v2/dataflow.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e5f7a22a36d99541326dbe109c7e1b26dee5c1ec
GIT binary patch
literal 12941
zcmcgy>vr455$<n2#f0^VL7SKO@{6)%DU#!;rDY$>N!z2UCIl=g)F8lMK}oE_bNZ_f
z(9?J5d-PHAB>iUg0)V7^OKhK$hy)k2vvc|8+u7~kxwA!gX!xK%d`NLvhT}B9q+kB^
zZz|6fUEHU#P^w3-i!jsUyqIe9{2q;FMLsFQ=^OlScCJSh?0@%+`t<VP*~#PmgJ*XS
z4xXLj`|-iE4$tsbEmTZr3kq~H$-;78s17ArsV1tRERWTjByP9)NiI`_ah#ONh3f9V
zd`7c0jMP+R<p82s8bM<Ux*<Ji4`@<AWfex}6oqLTo~7!xrqNj*FRqs(x=hM*(q&kR
z0GUctaF<5AkXI~5eSEk|%2B&RVHVSQm`%(Kn8f{KTR^iS?7A69#S=woqDxE_jVBNj
z#r*#m|EJ(AEbwcN(UioxO?f7Za&PzS8Xn3T9%2nxu8h!&43m{f1pV0FVfrS?21l%=
z{hH59e0wz9>4#A{uYRvR;UQ~lV0+MoDj-|wj!af92|gI<`E(k>AhIfB3|@CQo25w<
zmPwv<b(GK4n&ha+wXQ5PnuQz}Nd`5|N7l#MDj3hxbkY3@iYMa)5iyFw>@eOHTaCn6
zY#g3rk7fuGDimC*Qp(44c^;M~II=KZ`~ymdX`w=_E6S&{c?og9{PRC>F<$D1JVqzF
zN5@KZ?nP-hk5&J8|NE!U_ud>l-9J1&d~tN#o5u9N|5EEXI#<(>V}6<-sCmIH2?>`L
zT@&gUFaA41(01P@h?yyDlw=bM5Q+0Fh8l_S_r*P$VpQ7ZxJ58Y#38wEo7lVEAr3wB
z03U8s5T-h(+cjU`rchHzFZW*UJ%97!hu3`*23^<`%0=gS(U$xo5?e!7lyjs;Yz-a+
zyRjRQFG$esN;ZcTgqJjY*s1b^bxD&<4Wc}~&CBd>Z6(uLUcm5+nWAgjA5Wel_B-^9
z6Q7OHp_j3J_R@fY{G@3~<079@tJmur)3vr&guOoAtHP^3UW+r<#{YPK-==tne!TyZ
z1I;M&<Na58URDzNVt2g1#TZkJfgd#Fd_0UbU2hSf0%146!V7qATOJtf7(lR_grDnj
zTFRRPdLGUmW%KEoD%fKD;?6ep`^K$(c4fZ_G>B)xQpr6B2aqYQI%*0uf{j4=U7*TI
zh!vvO1SNtiR#$Z7<%Cn!6jj%4T@**dC?Ag~!;28Ydb25v0^3{5t*!o@JM`^5New2=
zR8eKOg=)l!tfz|=BK(1<8s<n9>3m*9s+*6yWibcxB3wxUb`}OP3w2o}rE2#$vc~f)
z;xwZ(p3Au>Xt<{1LA~ynj=}Lk6@(|JKv5^ccsS2=S-FoMQ>HFA`7mgU|7E!G%!aYn
zJ?mp(#0|r(3+lt?8X0MnI9BDO4I^Z7jWIBR2}Vx-dG<ETFEjplZ6Ze@qV<yj?G;71
zcyuj}bfHYk9a^?~B1*>5lP7d?$}3D&X`PKJy7%0p*<pNz2jB2__ErD@f#EVn4)!+6
z*EN13O2!mqJwd$3j~`P@(5%(2Ox)9|#E2yBP|F}(OH7LxOEoI!>iY;hyl#ZMIAjY!
z0xQG+eD*bE%bRA*a<gzTKux-FY)uL;+iK?$60WQdV06(ZJnr;KkCTN>ISPx(t!sX`
z996I5>)pEzecY<p=-@tB*67xC)&o8i<r_xW<)Hcwu$@n{<;bm?Eydx|I}de$w?T}&
z418Gro?lI3yuk3|@ETPx1tZ~vLV8ln?w=+ZI11=Qoak_RmQ3bS*sOJB4p0x7!%e=)
z<g9~T9$sDIze0h+Wr#@0)+$RG87*LTEY7*Vu%Ib;hcPWZ&VYJ?F7`ne4d4|@!x{_=
zU`0j(!ZHPHqpsziwozcSg_%~Y#;|D2)l7m?%G!e!kVzi|X;NW?fshLL03RkLB_Qqc
z(!^xak$8f$;V^E~6Cd6*AP9w5?UH*F&Hy(I(XyMtRq|cJ#b7Iwf$wTOXn}>gjPIH<
zAr*stE`%6AH#rtiHyAzg?<Dcg?jw0|XVeyQa_o5|gaDmuY}fM04Yaad@u{!?VoRmi
zMUc&M4KkjCQE?n<);}1zup4#Ae|DVo&Ztc=g_A&9vA0T~%dAi{#T=;zf+xO4aS+R+
zi137NQ9KDF37%yrF(n9r8Bl<waS1Hw#VdKEdca(tIZpyso`M)MDI4vM43F{EX8e=K
z*NOskh)w=SwQymuF&^v~lg9c_m@a7T0%hRoTh~tW!+3e?+K$8qWU%tvZtX|O0<V~!
zh1rX7fWY_M3R+ylIslCUojC4c{+@0l*ipCFAD=BsrPqG|J7QGwnd`;YPzhOKzZpzA
zMaG&*diX2A#Y6bBAK<3@rbFMHy3FoV_p|=n0`P&;GT)b6@x)8hUBZT}kL_3=o3Yic
z*V^8U1$|acyIU2}QPZRxZo(nB%lrHUM#l=6*y6F}+b5^=GpK+?IzXzS+!$cVcXI&Z
z<{}45u)|F~k5GaDRW3*w&9U-lymuA@%05}pQ<yBQ=uK*9Km&1`n~ZJAT02ZQ|L`6*
z-Wg-j$8ic*wpo6X&6O!SW(5p~vW6A7MI{7sX$#-x4X&U(9viW!$Lnje8H`9?_gkfA
z20Rh~OF__g#HIl&23m8_p!QhQtLiFN19OVJ6G%T5vQiNuZ?F~s;hOk|0kx{9sEx>Q
z0F2G^HZqd)+YB_+YQq>_5ekPPU@kBmZ!)IA(~1u2B61+MO|b@Yn8LPgC$eP@MDej@
zh7BiS^<y7@ZW=RrvmB}(a0w_6cG9q|+vSQc(E^gcU?lQ)AY<+RG`tKKVpA8SP~Es#
z#+s@NP9}Sb_txENpbrMm(2SX2j7<^b7qS{fP-{Ht&F1<%016jTht1isW>kg>FKfhz
zg9C414ivcgOa=JTp+L3i@eWr3Xjnwc-|+_sG9TFa;09P^Q3la;_CVx$f4e+)j<EiY
zKfvF-6{tLHE$|^PZqr3rV1MDl2Ccpe_YE-95L??ZNZ_pMYXS!r=I()P8^HEzynMy;
zjEyKc&gCYVCF^8UVjbv4+4!qQaoTeXeTDrA#v(A|HUD9I<X))l9qJl_i#9Z5sV+uj
z4afttYhH<bL#?DYgH908W@4H6SQQ2MDflbetO2w0T}#6-tZh?30GVwKuQ3w>)_1|s
z>G{*w-@iBjjQ}yePzP%KgH|J?k+i%t<LhNu@HTwWMK>%u$FyCk6T;cRo58T^Q@rh_
z3F;8@<p{k%jRY;vwP}=w#0}tXl4+GO=eqzQ%V&!|dUa{sMbnN`Ykr2vKtq)ROal#j
zr3TkNEbEgbnvPz)rsLy1w5ekGJj+35b+^pBIr2YM-Lo)y3oW>Yqw964s0=6IZq%wT
zL${cz<Du4Ji|dK`2MlNa2uA9~QW`D*<-s2mT8wB)y`t~hbeYf5#^AckJyyqJ71vgt
zZi4w+UP4Vis6#FB2PC_PT4V|o)E?VV>~QJ~5Wx6@A}xt?va%jzP!)l)Al^_3c7U%`
z*b%=AJ8Fn=-%5*m%y<0z`0_sNfs(wZZMEtEbP!K01o3X=vy&stfSiyR@Ou{5re+di
zy3$okq>YDC9nfL!n-5I+gIb@u{RPxs;dBp!0{usBQE?v<o(DcRnxTByG0sh&&fsdt
zx2tyQYz_AKP8$EdS&s!<I4~$up-k7I3_D(88Z#pW9LZauUne+v>Ckv`$`$^_+22)E
zg2|(isdO-#^xQr~qo7}#h!oIG69g4&FS}dFu<^#Q_*I(JFtGO02D;f`87F2}jNBG&
zJhOl_!>{~-2R5qMLoY|nwj5V#S@cXYphG@J9=eS>_i*Z)a5Ne?w^&z?+O&gqm!GIr
zgW}evNf2Ikmewt7o?5)caWcP(dNx8?o(tBh>cX35ztx|l`5DlPvH$6x4_}ja83uF>
zden;o>KM`iZG7}@te3ZuC|x-UizPPHmGJ9^S)~RuXNf0IdIsgB|K~iqUXHog(br!C
zvaAwZq`j%C_XsH{0D}tP8jmQoju)&j&G!%pG$@5si5=ON==8CyHI%IlKs^VWt~(0{
zAO2qrc56>>0O0Dy%}D%PuJnm8yC*&7b``WjM})?{bah<b@mZ<KVu_L)K#uXx#hLG8
z@I!MP=uu-O_YFCl^mIIVBXQw8YspPT&-R8xu%8B_=ZZg{qEzDic6eXl#hm+MTHaiB
zWz)o{!$)oSXUHaY2gup}-|#p1YkaqTs}I_wB5)~Rcxq5mXJF>I>+q;X!z}UTIf^<S
zIj-3A=gL;53H7f;tD?3b8y-g95TeY8l_s7S%S&rY9Nr|%7@(<~Nva!^V*?@e%zMru
zmHilZkL0{5z{rz(r(O?lVeD_Evpih7)|<d(QuUHCRBYyV{svyrLTg~1KTNhzXZqZb
zgNlL{D~{f2=zy=%kY_jAyFMvnuY;0a!*<3Wcmw$28yV}SM1u+y)QCfgZ;&wCxl;ue
zgX23KQlrOUnV9=cx!=|b2)5hafHmg7Zhd5?MQc7?9#E0s6ogv|_W0SnVOq`H`9`ml
zsXiBJ`yMmuimQIaf`&IP$DgRwDQ0~|64$kLt>+Vtk2fb2pJ4d{?<0Rbp>EE>cZRvi
zK}A3ROrM^Pc7{es2?N=Xj{LlVGG^y#DsjyOK8=_`uH+FO`SX~YatLEKCDAHjxFLmV
zVSzU`2D%UCM%`PDkt!V^XG4@5GRIk4MYbHn4rI5di8o^Ate#`ohId6XdEe@PC~&!k
zM__lTHir0bv=+{Us;GZxpdbJ6{Q2IiztntubIh8y(hbo3>49p+eo&wq<y<-UrHJjz
z_n17P{AkXFCXFGf26a(BK3{o}O+pB_zdMB_Spy(8BdNp~$E{tcv}jQbK1Zpt6SIOJ
zJ2T$-6$x(r+Q@9I-xe&f*jh!}l&fgAxMmD@XZT!Ht90CD9#=o#;FPSo_8(H2HfcDt
z`r+@p@(<-knv{T)1Ao#y#dbjM3IRrH8*+1T47&=xE_ZkBuAb8ZB5Rn4+V6UzPqEM+
z!$PWeZ3H9DrXfHscZ&ggSL}7Awq1nj92?!0%`IQIz;4F}qRYik$+-FnO|?bD{RzEM
z&81wm`4SBl>ByT#*_UXI;QA1s-tyJ1MRln(7(Ot!3eoPl<U`$2ii<%hZ^j?uxL8j2
zxysl(eO<m3RJtpu+&(eaKv8q<n6ny2$Zr?N2`*gn**DHS*CGp-`51?Bbd}HMDTc%p
z&-vn()H6P$3e&f8V&30US8~nG@5VTO7YFuAY+z&4cX;p}0|wN%!N&W_Bo>{TogUNi
z+2P+^q-_{gT|ASKVjg!dtFu*a5}CR&<Lwo+=wX|S3wG`<E{C3A9)1VqGFE<stFpEg
zflG0Y_;6xChPxQG)|fK)mumU+i7h0zXw2n4%KBG2O0HIe+he4)<jNRXnG<3uC68xv
ziN*&`TvqoKlKp%&34|8M{Ofnk>bF;n2-&%y55}exl>7B2_{c7rKPl#h9j^*kkPyk*
zT<5AD%3fZ+RxO`OZ8lbwWo_w$4^6L<dz7XriQ!+W)2pW_@N}+HbSd?hfFhsG=0NVz
z>z&{VXXdZ@j2$PqxW03RZ*o3of*)CiA8Y64S^=uwd2J76$h_p*ezjn^;_`Fluh5wQ
ze+zk-JaG5V*h@T(x$adzPDS{kGsZv3EiG{@@wHyVDU5*Hbu9eSyi$Uu)BPZnOC&e+
z>S&3ac=rI<#9TS4-yaG2EVCz<j?_NRqR=D=&iGlIQ!(TN&b43pNRIXMUg7i3cdNI0
zX#E~#SBGy@-53Rutg3tjyQV8YTvHYey!WXK&g73y-)r0ENh>xvn=IW_HwbIpvo)<T
fyE)NWQ{8eXR=;s`8osZ6->AT+x|##wW7PdW`Vqep

literal 0
HcmV?d00001

diff --git a/src/schema/v2/emit.ts b/src/schema/v2/emit.ts
new file mode 100644
index 0000000..3f0098b
--- /dev/null
+++ b/src/schema/v2/emit.ts
@@ -0,0 +1,382 @@
+/**
+ * v1 in-memory model → schema-v2 `analysis.json`. A pure transform: it reshapes the tree,
+ * assigns `can://` ids, and renames edge fields — it never re-parses. The parsing/resolution
+ * guts (buildSymbolTable, call graph, dataflow) are untouched; only this serialization is new.
+ *
+ * Level scope: this emits **L1** — the containment tree (modules → types/functions/fields →
+ * callables → `body` call nodes) with `can://` ids, precise spans, and per-module `source`.
+ * `call_graph`/`param_in`/`param_out` are emitted empty here and populated by later levels
+ * (`call_graph` at L2). The `idBySig` map built during the walk is what L2 will use to rewrite
+ * edges, and doubles as the L1 id-uniqueness gate.
+ */
+
+import * as path from "node:path";
+import type { AnalysisOptions } from "../../options";
+import type {
+  TSApplication,
+  TSCallable,
+  TSClass,
+  TSClassAttribute,
+  TSEnum,
+  TSInterface,
+  TSModule,
+  TSNamespace,
+  TSSpan,
+  TSTypeAlias,
+  TSVariableDeclaration,
+} from "../schema";
+import { applyDataflow } from "./dataflow";
+import type { V2Application, V2BodyNode, V2CallEdge, V2Callable, V2External, V2Field, V2Module, V2Node, V2Root, V2Type } from "./model";
+
+const LANGUAGE = "typescript";
+const SCHEMA_VERSION = "2.0.0";
+/** Highest analysis level this emitter populates today (L1 tree, L2 call graph, L3/L4 dataflow). */
+const MAX_IMPLEMENTED = 4;
+
+/** Structural / replaced / cache-metadata keys stripped before carrying language-native attrs. */
+const DROP = new Set<string>([
+  "code",
+  "span",
+  "path",
+  "file_path",
+  "module_name",
+  "start_line",
+  "end_line",
+  "start_column",
+  "end_column",
+  "code_start_line",
+  "bytes",
+  "methods",
+  "attributes",
+  "members",
+  "properties",
+  "classes",
+  "interfaces",
+  "enums",
+  "type_aliases",
+  "namespaces",
+  "functions",
+  "variables",
+  "call_sites",
+  "inner_callables",
+  "inner_classes",
+  "local_variables",
+  "content_hash",
+  "last_modified",
+  "file_size",
+  "callee_signature",
+]);
+
+/**
+ * Recursively drop `null`/`undefined` — the canonical convention is "a fact is present or absent;
+ * there is no null" (the one exception, a call node's `callee: null`, is set explicitly outside
+ * carry()). Nested nulls (e.g. a parameter's `default_value`, an import's `alias`) go too.
+ */
+function pruneNulls(v: unknown): unknown {
+  if (Array.isArray(v)) return v.map(pruneNulls);
+  if (v && typeof v === "object") {
+    const out: Record<string, unknown> = {};
+    for (const [k, val] of Object.entries(v)) {
+      if (val === null || val === undefined) continue;
+      out[k] = pruneNulls(val);
+    }
+    return out;
+  }
+  return v;
+}
+
+/** Copy a v1 node's language-native attributes (everything not structural/replaced), null-pruned. */
+function carry(node: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(node)) {
+    if (DROP.has(k) || v === null || v === undefined) continue;
+    out[k] = pruneNulls(v);
+  }
+  return out;
+}
+
+/** The containment-path id of a descendant, derived from its dotted signature. */
+function idFromSig(moduleId: string, modulePrefix: string, sig: string): string {
+  const tail = sig.startsWith(`${modulePrefix}.`) ? sig.slice(modulePrefix.length + 1) : sig;
+  return `${moduleId}/${tail.split(".").join("/")}`;
+}
+
+/** The map key for a callable/type within its parent: the last signature segment (+ accessor tag). */
+function memberKey(sig: string, accessorKind?: string | null): string {
+  const seg = sig.split(".").pop() ?? sig;
+  if (accessorKind === "getter") return `${seg}#get`;
+  if (accessorKind === "setter") return `${seg}#set`;
+  return seg;
+}
+
+/** State shared across the whole tree walk (edge-rewriting + gating). */
+interface SharedState {
+  idBySig: Map<string, string>;
+  collisions: string[];
+  pendingCallees: Array<{ node: V2BodyNode; calleeSig: string | null }>; // backfilled at L2
+  callableBySig: Map<string, V2Callable>; // locates each callable's node for the L3/L4 dataflow pass
+  level: number;
+}
+
+interface Ctx extends SharedState {
+  moduleId: string;
+  modulePrefix: string;
+}
+
+function register(ctx: Ctx, sig: string, id: string): void {
+  if (ctx.idBySig.has(sig) && ctx.idBySig.get(sig) !== id) ctx.collisions.push(sig);
+  ctx.idBySig.set(sig, id);
+}
+
+// ----------------------------------------------------------------------------------------------
+// body (L1: call sites → `call` nodes keyed by line:col)
+// ----------------------------------------------------------------------------------------------
+
+function toBody(c: TSCallable, ctx: Ctx): Record<string, V2BodyNode> {
+  const body: Record<string, V2BodyNode> = {};
+  for (const cs of c.call_sites ?? []) {
+    const span: TSSpan = {
+      start: [cs.start_line, cs.start_column],
+      end: [cs.end_line, cs.end_column],
+      bytes: cs.bytes ?? [0, 0],
+    };
+    let key = `${cs.start_line}:${cs.start_column}`;
+    for (let k = 2; key in body; k++) key = `${cs.start_line}:${cs.start_column}/${k}`; // chained calls share a start
+    const node: V2BodyNode = { ...carry(cs as unknown as Record<string, unknown>), kind: "call", span, callee: null };
+    body[key] = node;
+    // callee stays null at L1; backfilled to a can:// id at L2 once external/synth ids are homed.
+    ctx.pendingCallees.push({ node, calleeSig: cs.callee_signature ?? null });
+  }
+  return body;
+}
+
+// ----------------------------------------------------------------------------------------------
+// callable
+// ----------------------------------------------------------------------------------------------
+
+function toCallable(c: TSCallable, ctx: Ctx): V2Callable {
+  const id = idFromSig(ctx.moduleId, ctx.modulePrefix, c.signature);
+  register(ctx, c.signature, id);
+  const node: V2Callable = {
+    ...carry(c as unknown as Record<string, unknown>),
+    id,
+    kind: c.kind,
+    signature: c.signature,
+    span: c.span,
+    body: toBody(c, ctx),
+  };
+  ctx.callableBySig.set(c.signature, node); // for the L3/L4 dataflow pass
+  const nestedCallables = c.inner_callables ?? {};
+  if (Object.keys(nestedCallables).length) {
+    node.callables = {};
+    for (const inner of Object.values(nestedCallables)) node.callables[memberKey(inner.signature, inner.accessor_kind)] = toCallable(inner, ctx);
+  }
+  const nestedClasses = c.inner_classes ?? {};
+  if (Object.keys(nestedClasses).length) {
+    node.types = {};
+    for (const cls of Object.values(nestedClasses)) node.types[memberKey(cls.signature)] = toClass(cls, ctx);
+  }
+  return node;
+}
+
+// ----------------------------------------------------------------------------------------------
+// fields (module vars, class attributes, interface properties, enum members)
+// ----------------------------------------------------------------------------------------------
+
+function fieldNode(parentId: string, name: string, span: TSSpan | undefined, src: Record<string, unknown>): V2Field {
+  return { ...carry(src), id: `${parentId}/${name}`, kind: "field", span };
+}
+
+// ----------------------------------------------------------------------------------------------
+// type kinds
+// ----------------------------------------------------------------------------------------------
+
+function toClass(c: TSClass, ctx: Ctx): V2Type {
+  const id = idFromSig(ctx.moduleId, ctx.modulePrefix, c.signature);
+  register(ctx, c.signature, id);
+  const callables: Record<string, V2Callable> = {};
+  for (const m of Object.values(c.methods ?? {})) callables[memberKey(m.signature, m.accessor_kind)] = toCallable(m, ctx);
+  const fields: Record<string, V2Field> = {};
+  for (const [name, a] of Object.entries(c.attributes ?? {}))
+    fields[name] = fieldNode(id, name, (a as TSClassAttribute).span, a as unknown as Record<string, unknown>);
+  return { ...carry(c as unknown as Record<string, unknown>), id, kind: "class", signature: c.signature, span: c.span, callables, fields };
+}
+
+function toInterface(i: TSInterface, ctx: Ctx): V2Type {
+  const id = idFromSig(ctx.moduleId, ctx.modulePrefix, i.signature);
+  register(ctx, i.signature, id);
+  const callables: Record<string, V2Callable> = {};
+  for (const m of Object.values(i.methods ?? {})) callables[memberKey(m.signature, m.accessor_kind)] = toCallable(m, ctx);
+  const fields: Record<string, V2Field> = {};
+  for (const [name, p] of Object.entries(i.properties ?? {}))
+    fields[name] = fieldNode(id, name, (p as TSClassAttribute).span, p as unknown as Record<string, unknown>);
+  return { ...carry(i as unknown as Record<string, unknown>), id, kind: "interface", signature: i.signature, span: i.span, callables, fields };
+}
+
+function toEnum(e: TSEnum, ctx: Ctx): V2Type {
+  const id = idFromSig(ctx.moduleId, ctx.modulePrefix, e.signature);
+  register(ctx, e.signature, id);
+  const fields: Record<string, V2Field> = {};
+  for (const m of e.members ?? []) fields[m.name] = fieldNode(id, m.name, m.span, m as unknown as Record<string, unknown>);
+  return { ...carry(e as unknown as Record<string, unknown>), id, kind: "enum", signature: e.signature, span: e.span, fields };
+}
+
+function toTypeAlias(t: TSTypeAlias, ctx: Ctx): V2Type {
+  const id = idFromSig(ctx.moduleId, ctx.modulePrefix, t.signature);
+  register(ctx, t.signature, id);
+  return { ...carry(t as unknown as Record<string, unknown>), id, kind: "type_alias", signature: t.signature, span: t.span };
+}
+
+/** Gap A: a namespace is a nested *scope* — same buckets as a module (types/functions/fields). */
+function toNamespace(ns: TSNamespace, ctx: Ctx): V2Type {
+  const id = idFromSig(ctx.moduleId, ctx.modulePrefix, ns.signature);
+  register(ctx, ns.signature, id);
+  const types = collectTypes(ns, ctx);
+  const functions: Record<string, V2Callable> = {};
+  for (const fn of Object.values(ns.functions ?? {})) functions[memberKey(fn.signature, fn.accessor_kind)] = toCallable(fn, ctx);
+  const fields: Record<string, V2Field> = {};
+  for (const v of ns.variables ?? []) fields[v.name] = fieldNode(id, v.name, v.span, v as unknown as Record<string, unknown>);
+  return { ...carry(ns as unknown as Record<string, unknown>), id, kind: "namespace", signature: ns.signature, span: ns.span, types, functions, fields };
+}
+
+/** Merge a scope's class/interface/enum/type-alias/namespace buckets into one `types{}` map. */
+function collectTypes(scope: { classes?: Record<string, TSClass>; interfaces?: Record<string, TSInterface>; enums?: Record<string, TSEnum>; type_aliases?: Record<string, TSTypeAlias>; namespaces?: Record<string, TSNamespace> }, ctx: Ctx): Record<string, V2Type> {
+  const types: Record<string, V2Type> = {};
+  for (const c of Object.values(scope.classes ?? {})) types[memberKey(c.signature)] = toClass(c, ctx);
+  for (const i of Object.values(scope.interfaces ?? {})) types[memberKey(i.signature)] = toInterface(i, ctx);
+  for (const e of Object.values(scope.enums ?? {})) types[memberKey(e.signature)] = toEnum(e, ctx);
+  for (const t of Object.values(scope.type_aliases ?? {})) types[memberKey(t.signature)] = toTypeAlias(t, ctx);
+  for (const ns of Object.values(scope.namespaces ?? {})) types[memberKey(ns.signature)] = toNamespace(ns, ctx);
+  return types;
+}
+
+// ----------------------------------------------------------------------------------------------
+// module
+// ----------------------------------------------------------------------------------------------
+
+function toModule(m: TSModule, moduleId: string, shared: SharedState): V2Module {
+  const ctx: Ctx = { moduleId, modulePrefix: m.module_name, ...shared };
+  const types = collectTypes(m, ctx);
+  const functions: Record<string, V2Callable> = {};
+  for (const fn of Object.values(m.functions ?? {})) functions[memberKey(fn.signature, fn.accessor_kind)] = toCallable(fn, ctx);
+  const fields: Record<string, V2Field> = {};
+  for (const v of m.variables ?? []) fields[(v as TSVariableDeclaration).name] = fieldNode(moduleId, v.name, v.span, v as unknown as Record<string, unknown>);
+  return {
+    ...carry(m as unknown as Record<string, unknown>),
+    id: moduleId,
+    kind: "module",
+    source: m.source ?? "",
+    span: m.span,
+    types,
+    functions,
+    fields,
+  };
+}
+
+// ----------------------------------------------------------------------------------------------
+// L2 — edge-endpoint id homes (external library targets + first-party anonymous callbacks)
+// ----------------------------------------------------------------------------------------------
+
+/** External library call targets → `can://…/@external/<module>/<name>` ids on the application root. */
+function homeExternals(app: TSApplication, appId: string, idBySig: Map<string, string>): Record<string, V2External> {
+  const out: Record<string, V2External> = {};
+  for (const [sig, ext] of Object.entries(app.external_symbols ?? {})) {
+    const id = `${appId}/@external/${ext.module}/${ext.name}`;
+    idBySig.set(sig, id);
+    out[id] = { id, kind: "external", module: ext.module, name: ext.name };
+  }
+  return out;
+}
+
+/**
+ * First-party anonymous callbacks (Jelly resolves them as endpoints; the symbol table never names
+ * them). Their v1 signature is `<enclosing-sig>:<line:col>`, so they are addressed *ordinally* under
+ * the enclosing callable: `<enclosing-can-id>@<line>:<col>` (the two-tier identity rule below the
+ * callable line).
+ */
+function homeSynthesized(app: TSApplication, appId: string, idBySig: Map<string, string>): Record<string, V2Node> {
+  const out: Record<string, V2Node> = {};
+  for (const [sig, sc] of Object.entries(app.synthesized_callables ?? {})) {
+    const m = /^(.*):<?(\d+):(\d+)>?$/.exec(sig);
+    const enclosing = m ? idBySig.get(m[1] as string) : undefined;
+    const id = m && enclosing ? `${enclosing}@${m[2]}:${m[3]}` : `${appId}/@synthetic/${encodeURIComponent(sig)}`;
+    idBySig.set(sig, id);
+    out[id] = {
+      id,
+      kind: "callable",
+      name: sc.name,
+      path: sc.path,
+      span: { start: [sc.start_line, sc.start_column], end: [sc.start_line, sc.start_column], bytes: [0, 0] },
+    };
+  }
+  return out;
+}
+
+// ----------------------------------------------------------------------------------------------
+// entry point
+// ----------------------------------------------------------------------------------------------
+
+export interface ToV2Result {
+  application: V2Application;
+  idBySig: Map<string, string>; // signature → can:// id (real callables + externals + synthesized)
+  collisions: string[]; // signatures that mapped to two distinct ids (L1 id-uniqueness gate)
+  dangling: string[]; // call-graph endpoints with no id home (L2 no-dangling gate; should be empty)
+}
+
+export function toV2Detailed(app: TSApplication, opts: AnalysisOptions): ToV2Result {
+  const level = opts.analysisLevel;
+  const appName = (opts.appName ?? (opts.input ? path.basename(opts.input) : "") ?? "").trim() || "app";
+  const appId = `can://${LANGUAGE}/${appName}`;
+  const idBySig = new Map<string, string>();
+  const collisions: string[] = [];
+  const pendingCallees: Array<{ node: V2BodyNode; calleeSig: string | null }> = [];
+  const callableBySig = new Map<string, V2Callable>();
+  const shared: SharedState = { idBySig, collisions, pendingCallees, callableBySig, level };
+
+  // L1 — the containment tree (registers every real callable/type id in idBySig).
+  const symbol_table: Record<string, V2Module> = {};
+  for (const [fileKey, m] of Object.entries(app.symbol_table)) {
+    symbol_table[fileKey] = toModule(m, `${appId}/${fileKey}`, shared);
+  }
+  const root: V2Root = { id: appId, kind: "application", symbol_table, call_graph: [], param_in: [], param_out: [] };
+
+  // L2 — home the off-tree edge endpoints, backfill `callee`, rewrite the call graph.
+  const dangling: string[] = [];
+  if (level >= 2) {
+    root.external_symbols = homeExternals(app, appId, idBySig);
+    root.synthesized_callables = homeSynthesized(app, appId, idBySig);
+    for (const { node, calleeSig } of pendingCallees) {
+      if (calleeSig) node.callee = idBySig.get(calleeSig) ?? null;
+    }
+    root.call_graph = (app.call_graph ?? [])
+      .map((e): V2CallEdge | null => {
+        const src = idBySig.get(e.source);
+        const dst = idBySig.get(e.target);
+        if (!src) dangling.push(e.source);
+        if (!dst) dangling.push(e.target);
+        return src && dst ? { src, dst, prov: e.provenance, weight: e.weight } : null;
+      })
+      .filter((e): e is V2CallEdge => e !== null);
+  }
+
+  // L3/L4 — grow body{} + cfg/cdg/ddg/summary on callables and param_in/param_out on the app.
+  let k_limit: number | undefined;
+  if (level >= 3 && app.program_graphs) {
+    applyDataflow(root, app, idBySig, callableBySig, level);
+    k_limit = app.program_graphs.k_limit;
+  }
+
+  const application: V2Application = {
+    schema_version: SCHEMA_VERSION,
+    language: LANGUAGE,
+    max_level: Math.min(level, MAX_IMPLEMENTED),
+    ...(k_limit !== undefined ? { k_limit } : {}),
+    application: root,
+  };
+  return { application, idBySig, collisions, dangling };
+}
+
+/** The default L1 emitter surface: v1 app + options → schema-v2 Application. */
+export function toV2(app: TSApplication, opts: AnalysisOptions): V2Application {
+  return toV2Detailed(app, opts).application;
+}
diff --git a/src/schema/v2/index.ts b/src/schema/v2/index.ts
new file mode 100644
index 0000000..645e29b
--- /dev/null
+++ b/src/schema/v2/index.ts
@@ -0,0 +1,4 @@
+// Schema v2 — the canonical additive-CPG shape and the v1→v2 emitter (see canonical-schema.md).
+export * from "./model";
+export * from "./emit";
+export * from "./dataflow";
diff --git a/src/schema/v2/model.ts b/src/schema/v2/model.ts
new file mode 100644
index 0000000..a2a19af
--- /dev/null
+++ b/src/schema/v2/model.ts
@@ -0,0 +1,122 @@
+/**
+ * Schema v2 — the canonical CLDK analysis shape (the "additive CPG"): one scale-free node
+ * (id / kind / span / children / typed-edge overlays), emitted as `analysis.json`. This file is
+ * the TypeScript projection of `codeanalyzer-backend/references/canonical-schema.md`; the SDK's
+ * Pydantic models mirror it. It is produced by `emit.ts` as a transform of the v1 in-memory
+ * model (`../schema.ts`) — the parsing/resolution guts are untouched; only serialization changes.
+ *
+ * Levels are additive: L1 grows the tree to callable depth (+ `call` nodes in `body`); L2 adds
+ * `call_graph` and backfills `callee`; L3 grows the rest of `body` + `cfg`/`cdg`/`ddg`; L4 adds
+ * synthetic param vertices + `param_in`/`param_out`/`summary`. This file already declares the
+ * later-level slots (all optional) so the shape is stable as levels land.
+ */
+
+import type { TSSpan } from "../schema";
+
+/** The one universal attribute. `bytes` are char offsets into the owning module's `source`. */
+export type Span = TSSpan;
+
+// ----------------------------------------------------------------------------------------------
+// Root
+// ----------------------------------------------------------------------------------------------
+
+export interface V2Application {
+  schema_version: string; // "2.0.0"
+  language: string; // "typescript"
+  max_level: number; // highest level populated; consumers read this, not key-sniffing
+  k_limit?: number; // access-path depth bound for the L3/L4 dataflow (present at L3+)
+  application: V2Root;
+}
+
+export interface V2Root {
+  id: string; // can://<lang>/<app>
+  kind: "application";
+  symbol_table: Record<string, V2Module>; // keyed by project-relative POSIX path (with extension)
+  call_graph: V2CallEdge[]; // L2 — callable → callable (empty at L1)
+  param_in: V2ParamEdge[]; // L4 (empty until L4)
+  param_out: V2ParamEdge[]; // L4
+  // TS-additive (parity): edge endpoints outside the containment tree need an id home.
+  external_symbols?: Record<string, V2External>; // L2 — imported/library call targets, keyed by id
+  synthesized_callables?: Record<string, V2Node>; // L2 — first-party anonymous callbacks, keyed by id
+}
+
+/** A call target outside the project (an imported library member / builtin) — an edge endpoint, not a tree node. */
+export interface V2External extends V2Node {
+  kind: "external";
+  module: string; // the import/require specifier, e.g. "node:fs", "express"
+  name: string; // the called member, e.g. "readFileSync"
+}
+
+// ----------------------------------------------------------------------------------------------
+// Cross-callable edges (application scope)
+// ----------------------------------------------------------------------------------------------
+
+export interface V2CallEdge {
+  src: string; // caller callable id
+  dst: string; // callee callable (or external) id
+  prov: string[]; // provenance, e.g. ["tsc"], ["jelly"]
+  weight: number;
+}
+
+export interface V2ParamEdge {
+  src: string;
+  dst: string;
+  var?: string;
+}
+
+// ----------------------------------------------------------------------------------------------
+// Nodes — one scale-free node; language-native attrs ride additively via the index signature.
+// ----------------------------------------------------------------------------------------------
+
+export interface V2Node {
+  id: string;
+  kind: string;
+  span?: Span;
+  [attr: string]: unknown; // additive language-native attributes (decorators, is_*, type_parameters, …)
+}
+
+/** A file / compilation unit — a *scope* holding types, functions, and free bindings. */
+export interface V2Module extends V2Node {
+  kind: "module";
+  source: string; // whole file text, once; every node's text slices off this
+  types: Record<string, V2Type>; // classes/interfaces/enums/type-aliases/namespaces
+  functions: Record<string, V2Callable>; // free functions
+  fields: Record<string, V2Field>; // module-level const/let/var (Gap B → fields on the scope)
+}
+
+/**
+ * A type-or-scope node. Classes/interfaces/enums/type-aliases populate `callables`/`fields`;
+ * a `namespace` (a sub-file scope, Gap A) instead populates `types`/`functions`/`fields`.
+ */
+export interface V2Type extends V2Node {
+  kind: "class" | "interface" | "enum" | "type_alias" | "namespace";
+  signature: string; // v1 human-readable id (kept; the durable id is `id`)
+  callables?: Record<string, V2Callable>; // class/interface/enum members
+  fields?: Record<string, V2Field>; // class attributes / interface properties / enum members
+  types?: Record<string, V2Type>; // namespace: nested types
+  functions?: Record<string, V2Callable>; // namespace: nested functions
+}
+
+export interface V2Callable extends V2Node {
+  kind: "function" | "method" | "constructor" | "getter" | "setter" | "arrow" | "function_expression";
+  signature: string;
+  body: Record<string, V2BodyNode>; // L1: `call` nodes keyed by line:col; L3+: full statements
+  callables?: Record<string, V2Callable>; // nested callables (closures) — syntactic containment
+  types?: Record<string, V2Type>; // nested (local) classes
+  cfg?: unknown[]; // L3
+  cdg?: unknown[]; // L3
+  ddg?: unknown[]; // L3→L4
+  summary?: unknown[]; // L4
+}
+
+export interface V2Field extends V2Node {
+  kind: "field";
+}
+
+/** A node inside a callable `body` (L1: call sites; L3+: statements; L4: synthetic vertices). */
+export interface V2BodyNode {
+  kind: string; // "call" | "statement" | "return" | "entry" | "exit" | "formal_in" | …
+  span?: Span;
+  callee?: string | null; // on `call` nodes: null at L1, backfilled to a callable id at L2
+  [attr: string]: unknown;
+}
diff --git a/src/syntactic_analysis/builders.ts b/src/syntactic_analysis/builders.ts
index f9a0fba..36f38ca 100644
--- a/src/syntactic_analysis/builders.ts
+++ b/src/syntactic_analysis/builders.ts
@@ -20,6 +20,7 @@ import {
   type TSModule,
   type TSNamespace,
   type TSOverloadSignature,
+  type TSSpan,
   type TSTypeAlias,
   type TSTypeParameter,
   type TSVariableDeclaration,
@@ -86,6 +87,20 @@ function span(node: Node): { start_line: number; end_line: number; start_column:
   return { start_line: s.line, end_line: e.line, start_column: s.column, end_column: e.column };
 }
 
+/**
+ * schema-v2 precise span: [line, column] endpoints + char offsets into the module source.
+ * `bytes = [getStart(), getEnd()]` are exactly the offsets `Node.getText()` slices, so
+ * `module.source.slice(bytes[0], bytes[1])` reproduces the node's text (the old `code` field).
+ */
+function richSpan(node: Node): TSSpan {
+  const sf = node.getSourceFile();
+  const s = node.getStart();
+  const e = node.getEnd();
+  const sl = sf.getLineAndColumnAtPos(s);
+  const el = sf.getLineAndColumnAtPos(e);
+  return { start: [sl.line, sl.column], end: [el.line, el.column], bytes: [s, e] };
+}
+
 function declLines(node: Node): { start_line: number; end_line: number; code_start_line: number } {
   return {
     start_line: node.getStartLineNumber(true),
@@ -243,6 +258,7 @@ function buildVariable(vd: Node, scope: TSVariableDeclaration["scope"]): TSVaria
     is_readonly: declaration_kind === "const",
     is_exported: vs?.isExported?.() ?? false,
     ...span(vd),
+    span: richSpan(vd),
   };
 }
 
@@ -253,6 +269,7 @@ function buildAttribute(prop: Node): TSClassAttribute {
     getInitializer?: () => { getText: () => string } | undefined;
   };
   return {
+    span: richSpan(prop),
     name: p.getName(),
     type: p.getTypeNode?.()?.getText() ?? inferredType(prop),
     comments: jsDocsOf(prop),
@@ -296,6 +313,7 @@ function buildCallsite(call: Node): TSCallsite {
     is_constructor_call: isNew,
     is_optional_chain,
     ...span(call),
+    bytes: [call.getStart(), call.getEnd()],
   };
 }
 
@@ -434,6 +452,7 @@ export function buildCallable(
     Node.isConstructorDeclaration(fnNode) ? "constructor" : (nameNode.getName?.() ?? "(anonymous)");
 
   const callable: TSCallable = {
+    span: richSpan(sigNode),
     name,
     path: sigNode.getSourceFile().getFilePath(),
     signature: sig,
@@ -473,6 +492,7 @@ function implicitConstructor(classSig: string, filePath: string): { sig: string;
   return {
     sig,
     callable: {
+      span: { start: [0, 0], end: [0, 0], bytes: [0, 0] }, // synthetic: no source
       name: "constructor",
       path: filePath,
       signature: sig,
@@ -623,6 +643,7 @@ export function buildClass(cls: Node, root: string): { sig: string; cls: TSClass
   return {
     sig,
     cls: {
+      span: richSpan(cls),
       name: c.getName?.() ?? "(anonymous)",
       signature: sig,
       comments: jsDocsOf(cls),
@@ -673,6 +694,7 @@ export function buildInterface(intf: Node, root: string): { sig: string; intf: T
   return {
     sig,
     intf: {
+      span: richSpan(intf),
       name: i.getName(),
       signature: sig,
       comments: jsDocsOf(intf),
@@ -702,6 +724,7 @@ export function buildEnum(en: Node, root: string): { sig: string; en: TSEnum } {
     };
     const v = mm.getValue?.();
     return {
+      span: richSpan(m),
       name: mm.getName(),
       value: v !== undefined && v !== null ? String(v) : (mm.getInitializer?.()?.getText() ?? null),
       start_line: m.getStartLineNumber(true),
@@ -711,6 +734,7 @@ export function buildEnum(en: Node, root: string): { sig: string; en: TSEnum } {
   return {
     sig,
     en: {
+      span: richSpan(en),
       name: e.getName(),
       signature: sig,
       comments: jsDocsOf(en),
@@ -731,6 +755,7 @@ export function buildTypeAlias(ta: Node, root: string): { sig: string; ta: TSTyp
   return {
     sig,
     ta: {
+      span: richSpan(ta),
       name: t.getName(),
       signature: sig,
       comments: jsDocsOf(ta),
@@ -822,6 +847,7 @@ export function buildNamespace(ns: Node, root: string): { sig: string; ns: TSNam
   return {
     sig,
     ns: {
+      span: richSpan(ns),
       name: (ns as unknown as { getName: () => string }).getName(),
       signature: sig,
       comments: jsDocsOf(ns),
@@ -945,7 +971,12 @@ export function buildModule(sf: Node, root: string): TSModule {
   const filePath = sf.getSourceFile().getFilePath();
   const { fileKey, modulePrefix } = fileKeyOf(filePath, root);
   const buckets = buildStatemented(sf, root, "module");
+  // schema-v2: retain the whole file text once on the module; every node's text slices off it.
+  const source = (sf as unknown as { getFullText: () => string }).getFullText();
+  const endLc = sf.getSourceFile().getLineAndColumnAtPos(source.length);
   return {
+    span: { start: [1, 1], end: [endLc.line, endLc.column], bytes: [0, source.length] },
+    source,
     file_path: fileKey,
     module_name: modulePrefix,
     imports: buildImports(sf),
diff --git a/src/utils/serialize.ts b/src/utils/serialize.ts
index 2b2dd9a..0a68546 100644
--- a/src/utils/serialize.ts
+++ b/src/utils/serialize.ts
@@ -3,6 +3,7 @@ import * as path from "node:path";
 import { boltWriter, buildSchemaDocument, project, renderCypher } from "../build/neo4j";
 import type { AnalysisOptions } from "../options";
 import type { TSApplication } from "../schema";
+import { toV2, toV2Detailed } from "../schema/v2";
 import { Logger } from "./logging";
 
 /**
@@ -17,12 +18,14 @@ export async function emit(app: TSApplication, opts: AnalysisOptions): Promise<v
     await emitNeo4j(app, opts);
     return;
   }
+  // schema v2: reshape the v1 model into the canonical additive-CPG tree before serializing.
+  const out = toV2(app, opts);
   if (opts.output === null) {
-    process.stdout.write(JSON.stringify(app));
+    process.stdout.write(JSON.stringify(out));
     return;
   }
   fs.mkdirSync(opts.output, { recursive: true });
-  fs.writeFileSync(path.join(opts.output, "analysis.json"), JSON.stringify(app));
+  fs.writeFileSync(path.join(opts.output, "analysis.json"), JSON.stringify(out));
 }
 
 /**
@@ -40,8 +43,11 @@ export function emitSchema(opts: AnalysisOptions): void {
 }
 
 async function emitNeo4j(app: TSApplication, opts: AnalysisOptions): Promise<void> {
-  const appName = opts.appName ?? path.basename(opts.input);
-  const rows = project(app, appName);
+  // Second projection of the SAME v2 tree the JSON path emits. --emit neo4j forces full depth
+  // (cli.ts), so `app` carries the L4 dataflow and the projected graph is the complete CPG.
+  const { application } = toV2Detailed(app, opts);
+  const appId = application.application.id;
+  const rows = project(application, appId);
 
   if (opts.neo4jUri) {
     const log = new Logger(opts.verbosity);
@@ -61,5 +67,5 @@ async function emitNeo4j(app: TSApplication, opts: AnalysisOptions): Promise<voi
 
   const dir = opts.output ?? process.cwd();
   fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, "graph.cypher"), renderCypher(rows, appName));
+  fs.writeFileSync(path.join(dir, "graph.cypher"), renderCypher(rows, appId));
 }
diff --git a/test/neo4j-schema.test.ts b/test/neo4j-schema.test.ts
index cbeffb6..389e766 100644
--- a/test/neo4j-schema.test.ts
+++ b/test/neo4j-schema.test.ts
@@ -15,25 +15,25 @@ import {
   REL_TYPES,
   buildSchemaDocument,
   project,
-  twinOf,
-  withTwins,
 } from "../src/build/neo4j";
 import { analyze } from "../src/core";
 import type { AnalysisOptions } from "../src/options";
+import { toV2Detailed } from "../src/schema/v2";
 
-const FIXTURE = path.resolve(import.meta.dir, "fixtures/sample-app");
+const FIXTURE = path.resolve(import.meta.dir, "fixtures/dataflow-app");
 
 async function fixtureRows() {
   const cacheDir = fs.mkdtempSync(path.join(os.tmpdir(), "cants-schema-test-"));
+  // --emit neo4j is always full-depth, so exercise every node/edge kind at L4.
   const opts: AnalysisOptions = {
-    input: FIXTURE, output: null, emit: "json", appName: "sample-app",
+    input: FIXTURE, output: null, emit: "neo4j", appName: "dataflow-app",
     neo4jUri: null, neo4jUser: "neo4j", neo4jPassword: "", neo4jDatabase: null,
-    analysisLevel: 1, graphs: ["cfg", "dfg", "pdg", "sdg"], graphFieldDepth: 3, jobs: 1,
+    analysisLevel: 4, graphs: ["cfg", "dfg", "pdg", "sdg"], graphFieldDepth: 3, jobs: 1,
     targetFiles: null, skipTests: true, eager: true,
-    noBuild: true, phantoms: true, callGraphProvider: "tsc", cacheDir, verbosity: 0,
+    noBuild: true, phantoms: true, callGraphProvider: "union", cacheDir, verbosity: 0,
   };
   try {
-    return project(await analyze(opts), "sample-app");
+    return project(toV2Detailed(await analyze(opts), opts).application);
   } finally {
     fs.rmSync(cacheDir, { recursive: true, force: true });
   }
@@ -43,17 +43,13 @@ const byLabel = new Map(NODE_LABELS.map((n) => [n.label, n]));
 const mergeOf = new Map(NODE_LABELS.map((n) => [n.label, n.mergeLabel]));
 const relByType = new Map(REL_TYPES.map((r) => [r.type, r]));
 const markers = new Set<string>(MARKER_LABELS);
-const twins = new Set<string>([
-  ...NODE_LABELS.map((n) => twinOf(n.label)),
-  ...MARKER_LABELS.map((m) => twinOf(m)),
-]);
 const mergeLabelsFor = (specifics: string[]) => new Set(specifics.map((s) => mergeOf.get(s)));
 
-/** The specific (schema) label for a node row: the non-merge, non-marker, non-twin label. */
+/** The specific (schema) label for a node row: the non-merge, non-marker label (`Application`
+ * has only its own label; every `CanNode` carries exactly one specific kind label). */
 function specificLabel(labels: string[]): string {
   const merge = labels[0];
-  if (merge !== "Symbol") return merge;
-  return labels.find((l) => l !== "Symbol" && !markers.has(l) && !twins.has(l)) ?? "Symbol";
+  return labels.find((l) => l !== merge && !markers.has(l)) ?? merge;
 }
 
 const rows = await fixtureRows();
@@ -68,7 +64,7 @@ describe("neo4j schema conformance", () => {
       expect(node.labels[0]).toBe(decl!.mergeLabel);
 
       for (const label of node.labels) {
-        const ok = label === decl!.mergeLabel || label === specific || markers.has(label) || twins.has(label);
+        const ok = label === decl!.mergeLabel || label === specific || markers.has(label);
         expect(ok, `unexpected label '${label}' on ${specific}`).toBe(true);
       }
       for (const key of Object.keys(node.props)) {
@@ -94,20 +90,4 @@ describe("neo4j schema conformance", () => {
     const fresh = JSON.stringify(buildSchemaDocument(), null, 2).trim();
     expect(onDisk).toBe(fresh);
   });
-
-  test("every node carries exactly the TS twins of its base labels (1.1.0 dual-labeling)", () => {
-    for (const node of rows.nodes) {
-      const base = node.labels.filter((l) => !twins.has(l));
-      expect(new Set(node.labels), `bad twin set on ${node.labels.join(":")} ${node.value}`).toEqual(
-        new Set(withTwins(base)),
-      );
-      expect(twins.has(node.labels[0]), `merge label must stay bare: ${node.labels[0]}`).toBe(false);
-    }
-  });
-
-  test(":Application is stamped with the 1.1.0 contract version", () => {
-    const app = rows.nodes.find((n) => n.labels[0] === "Application");
-    expect(app).toBeDefined();
-    expect(app!.props.schema_version).toBe("1.1.0");
-  });
 });
diff --git a/test/schema-v2.test.ts b/test/schema-v2.test.ts
new file mode 100644
index 0000000..7c85c82
--- /dev/null
+++ b/test/schema-v2.test.ts
@@ -0,0 +1,425 @@
+/**
+ * Schema-v2 L1 emission gate: the v1 in-memory model transformed to the canonical additive-CPG
+ * tree (canonical-schema.md) must have the right envelope, well-formed unique `can://` ids, a
+ * byte-slice-able `source` per module (get_method_body), namespaces as container nodes, free
+ * bindings as module `fields{}`, and `body` `call` nodes at L1 — while remaining a superset of
+ * every v1 symbol-table fact.
+ */
+import { describe, expect, test } from "bun:test";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { analyze } from "../src/core";
+import type { AnalysisOptions } from "../src/options";
+import type { TSApplication } from "../src/schema";
+import { type V2Callable, type V2Module, type V2Type, toV2Detailed } from "../src/schema/v2";
+
+const FIXTURE = path.resolve(import.meta.dir, "fixtures/sample-app");
+
+function options(): AnalysisOptions {
+  return {
+    input: FIXTURE,
+    output: null,
+    emit: "json",
+    appName: null,
+    neo4jUri: null,
+    neo4jUser: "neo4j",
+    neo4jPassword: "",
+    neo4jDatabase: null,
+    analysisLevel: 1,
+    graphs: ["cfg", "dfg", "pdg", "sdg"],
+    graphFieldDepth: 3,
+    jobs: 1,
+    targetFiles: null,
+    skipTests: true,
+    eager: true,
+    noBuild: true,
+    phantoms: true,
+    callGraphProvider: "tsc",
+    cacheDir: null,
+    verbosity: 0,
+  };
+}
+
+async function run(): Promise<TSApplication> {
+  const cacheDir = fs.mkdtempSync(path.join(os.tmpdir(), "cants-v2-test-"));
+  try {
+    return await analyze({ ...options(), cacheDir });
+  } finally {
+    fs.rmSync(cacheDir, { recursive: true, force: true });
+  }
+}
+
+const v1 = await run();
+const { application: v2, idBySig, collisions } = toV2Detailed(v1, { ...options(), input: FIXTURE });
+const root = v2.application;
+const st = root.symbol_table;
+
+/** Every id in the tree, in walk order, for uniqueness + well-formedness checks. */
+function allIds(): string[] {
+  const out: string[] = [];
+  const walkCallable = (c: V2Callable): void => {
+    out.push(c.id);
+    for (const cc of Object.values(c.callables ?? {})) walkCallable(cc);
+    for (const t of Object.values(c.types ?? {})) walkType(t);
+  };
+  const walkType = (t: V2Type): void => {
+    out.push(t.id);
+    for (const c of Object.values(t.callables ?? {})) walkCallable(c);
+    for (const f of Object.values(t.fields ?? {})) out.push(f.id);
+    for (const st2 of Object.values(t.types ?? {})) walkType(st2);
+    for (const fn of Object.values(t.functions ?? {})) walkCallable(fn);
+  };
+  for (const m of Object.values(st) as V2Module[]) {
+    out.push(m.id);
+    for (const t of Object.values(m.types)) walkType(t);
+    for (const c of Object.values(m.functions)) walkCallable(c);
+    for (const f of Object.values(m.fields)) out.push(f.id);
+  }
+  return out;
+}
+
+describe("schema v2 — L1 envelope", () => {
+  test("root envelope matches the canonical shape", () => {
+    expect(v2.schema_version).toBe("2.0.0");
+    expect(v2.language).toBe("typescript");
+    expect(v2.max_level).toBe(1);
+    expect(Object.keys(root).sort()).toEqual(["call_graph", "id", "kind", "param_in", "param_out", "symbol_table"]);
+    expect(root.id).toBe("can://typescript/sample-app");
+    expect(root.kind).toBe("application");
+  });
+
+  test("edge lists are empty at L1 (populated at L2/L4)", () => {
+    expect(root.call_graph).toEqual([]);
+    expect(root.param_in).toEqual([]);
+    expect(root.param_out).toEqual([]);
+  });
+
+  test("symbol_table keys are project-relative POSIX paths", () => {
+    for (const key of Object.keys(st)) {
+      expect(path.isAbsolute(key)).toBe(false);
+      expect(key.includes("..")).toBe(false);
+      expect(key).not.toContain("\\");
+    }
+  });
+});
+
+describe("schema v2 — L1 identity", () => {
+  test("every can:// id is unique and well-formed", () => {
+    const ids = allIds();
+    expect(collisions).toEqual([]);
+    expect(new Set(ids).size).toBe(ids.length);
+    for (const id of ids) expect(id.startsWith("can://typescript/sample-app/")).toBe(true);
+  });
+
+  test("module ids derive from the file key", () => {
+    for (const [key, m] of Object.entries(st) as [string, V2Module][]) {
+      expect(m.id).toBe(`can://typescript/sample-app/${key}`);
+      expect(m.kind).toBe("module");
+    }
+  });
+});
+
+describe("schema v2 — L1 source & spans (get_method_body)", () => {
+  test("each module carries its full source", () => {
+    for (const m of Object.values(st) as V2Module[]) expect(typeof m.source).toBe("string");
+  });
+
+  test("a callable's span.bytes slices its declaration out of module.source", () => {
+    const svc = st["src/services.ts"];
+    const fn = svc.functions.makeGuestName;
+    expect(fn.kind).toBe("function");
+    const slice = svc.source.slice(fn.span!.bytes[0], fn.span!.bytes[1]);
+    expect(slice).toContain("makeGuestName");
+  });
+});
+
+describe("schema v2 — L1 tree shape", () => {
+  test("a namespace is a container node with types{} and functions{} (Gap A)", () => {
+    const ns = st["src/util.ts"].types.StringUtil;
+    expect(ns.kind).toBe("namespace");
+    expect(Object.keys(ns.types ?? {}).length).toBeGreaterThan(0);
+    expect(Object.keys(ns.functions ?? {}).length).toBeGreaterThan(0);
+    expect(ns.callables).toBeUndefined();
+  });
+
+  test("enum members and class attributes are field nodes (Gap B analog)", () => {
+    const role = st["src/models.ts"].types.Role;
+    expect(role.kind).toBe("enum");
+    expect(Object.keys(role.fields ?? {})).toContain("Admin");
+    for (const f of Object.values(role.fields ?? {})) expect(f.kind).toBe("field");
+  });
+
+  test("a callable's body holds L1 call nodes keyed by line:col with callee null", () => {
+    const create = st["src/services.ts"].types.UserService.callables?.create as V2Callable;
+    const keys = Object.keys(create.body);
+    expect(keys.length).toBeGreaterThan(0);
+    for (const k of keys) expect(k).toMatch(/^\d+:\d+(\/\d+)?$/);
+    for (const node of Object.values(create.body)) {
+      expect(node.kind).toBe("call");
+      expect(node.callee).toBeNull();
+    }
+  });
+});
+
+describe("schema v2 — L1 superset", () => {
+  test("every v1 callable/type signature has a v2 id", () => {
+    const v1sigs = new Set<string>();
+    const addType = (t: { signature: string; methods?: Record<string, { signature: string }> }): void => {
+      v1sigs.add(t.signature);
+      for (const m of Object.values(t.methods ?? {})) v1sigs.add(m.signature);
+    };
+    for (const m of Object.values(v1.symbol_table)) {
+      for (const t of Object.values(m.classes)) addType(t);
+      for (const t of Object.values(m.interfaces)) addType(t);
+      for (const t of Object.values(m.enums)) v1sigs.add(t.signature);
+      for (const t of Object.values(m.type_aliases)) v1sigs.add(t.signature);
+      for (const fn of Object.values(m.functions)) v1sigs.add(fn.signature);
+    }
+    const missing = [...v1sigs].filter((s) => !idBySig.has(s));
+    expect(missing).toEqual([]);
+  });
+});
+
+// ---- L2: call graph -------------------------------------------------------------------------
+async function runL2(): Promise<TSApplication> {
+  const cacheDir = fs.mkdtempSync(path.join(os.tmpdir(), "cants-v2-l2-"));
+  try {
+    return await analyze({ ...options(), analysisLevel: 2, cacheDir });
+  } finally {
+    fs.rmSync(cacheDir, { recursive: true, force: true });
+  }
+}
+const v1L2 = await runL2();
+const { application: v2L2, idBySig: idsL2, dangling: danglingL2 } = toV2Detailed(v1L2, { ...options(), analysisLevel: 2, input: FIXTURE });
+const rootL2 = v2L2.application;
+const knownIds = new Set(idsL2.values());
+
+describe("schema v2 — L2 call graph", () => {
+  test("max_level is 2 and the root gains external/synth maps", () => {
+    expect(v2L2.max_level).toBe(2);
+    expect(rootL2.external_symbols).toBeDefined();
+    expect(rootL2.synthesized_callables).toBeDefined();
+  });
+
+  test("edges are {src,dst,prov,weight} with can:// ids, no dangling endpoints", () => {
+    expect(rootL2.call_graph.length).toBeGreaterThan(0);
+    expect(danglingL2).toEqual([]);
+    for (const e of rootL2.call_graph) {
+      expect(Object.keys(e).sort()).toEqual(["dst", "prov", "src", "weight"]);
+      expect(knownIds.has(e.src)).toBe(true);
+      expect(knownIds.has(e.dst)).toBe(true);
+    }
+  });
+
+  test("body call-node callees are backfilled to a known id (null → id refinement)", () => {
+    let sawBackfill = false;
+    const scan = (c: V2Callable): void => {
+      for (const b of Object.values(c.body)) {
+        if (b.kind === "call" && b.callee != null) {
+          sawBackfill = true;
+          expect(knownIds.has(b.callee as string)).toBe(true);
+        }
+      }
+      for (const cc of Object.values(c.callables ?? {})) scan(cc);
+    };
+    for (const m of Object.values(rootL2.symbol_table)) {
+      for (const t of Object.values(m.types)) {
+        for (const c of Object.values(t.callables ?? {})) scan(c);
+        for (const fn of Object.values(t.functions ?? {})) scan(fn);
+      }
+      for (const fn of Object.values(m.functions)) scan(fn);
+    }
+    expect(sawBackfill).toBe(true);
+  });
+
+  test("external symbols are homed under @external as kind:external", () => {
+    for (const [id, ext] of Object.entries(rootL2.external_symbols ?? {})) {
+      expect(id).toContain("/@external/");
+      expect((ext as { kind: string }).kind).toBe("external");
+    }
+  });
+});
+
+// ---- L3/L4: dataflow into the tree ----------------------------------------------------------
+const DF_FIXTURE = path.resolve(import.meta.dir, "fixtures/dataflow-app");
+function dfOptions(level: 3 | 4): AnalysisOptions {
+  return { ...options(), input: DF_FIXTURE, analysisLevel: level, graphs: level >= 4 ? ["cfg", "dfg", "pdg", "sdg"] : ["cfg", "dfg", "pdg"] };
+}
+async function runDF(level: 3 | 4): Promise<TSApplication> {
+  const cacheDir = fs.mkdtempSync(path.join(os.tmpdir(), `cants-v2-l${level}-`));
+  try {
+    return await analyze({ ...dfOptions(level), cacheDir });
+  } finally {
+    fs.rmSync(cacheDir, { recursive: true, force: true });
+  }
+}
+
+/** Every callable node in the tree (module/type/namespace/nested recursion). */
+function allCallables(root: { symbol_table: Record<string, V2Module> }): V2Callable[] {
+  const out: V2Callable[] = [];
+  const wc = (c: V2Callable): void => {
+    out.push(c);
+    for (const cc of Object.values(c.callables ?? {})) wc(cc);
+    for (const t of Object.values(c.types ?? {})) wt(t);
+  };
+  const wt = (t: V2Type): void => {
+    for (const c of Object.values(t.callables ?? {})) wc(c);
+    for (const st of Object.values(t.types ?? {})) wt(st);
+    for (const fn of Object.values(t.functions ?? {})) wc(fn);
+  };
+  for (const m of Object.values(root.symbol_table)) {
+    for (const t of Object.values(m.types)) wt(t);
+    for (const fn of Object.values(m.functions)) wc(fn);
+  }
+  return out;
+}
+
+const dfL3 = toV2Detailed(await runDF(3), dfOptions(3)).application;
+const dfL4 = toV2Detailed(await runDF(4), dfOptions(4)).application;
+
+/** No intra-callable (bare-local) or cross-callable (canId@local) endpoint may dangle. */
+function danglingCount(app: typeof dfL3): number {
+  const root = app.application;
+  const callables = allCallables(root);
+  const bodies = new Map(callables.map((c) => [c.id, new Set(Object.keys(c.body))]));
+  const resolve = (ep: string): boolean => {
+    const at = ep.indexOf("@");
+    if (at < 0) return false;
+    const b = bodies.get(ep.slice(0, at));
+    const rem = ep.slice(at);
+    return !!b && (b.has(rem) || b.has(rem.slice(1))); // synthetic keeps '@'; positional strips the separator
+  };
+  let d = 0;
+  for (const c of callables) {
+    const body = bodies.get(c.id) as Set<string>;
+    for (const list of ["cfg", "cdg", "ddg", "summary"] as const) {
+      for (const e of (c[list] ?? []) as Array<{ src: string; dst: string }>) {
+        if (!body.has(e.src)) d++;
+        if (!body.has(e.dst)) d++;
+      }
+    }
+  }
+  for (const list of ["param_in", "param_out"] as const) {
+    for (const e of root[list]) {
+      if (!resolve(e.src)) d++;
+      if (!resolve(e.dst)) d++;
+    }
+  }
+  return d;
+}
+
+describe("schema v2 — L3 intraprocedural dataflow", () => {
+  test("max_level is 3; callables grow cfg/cdg/ddg with reaching-defs provenance", () => {
+    expect(dfL3.max_level).toBe(3);
+    expect(dfL3.k_limit).toBeGreaterThan(0);
+    let cfg = 0;
+    let ddgReaching = 0;
+    let ddgTotal = 0;
+    for (const c of allCallables(dfL3.application)) {
+      cfg += (c.cfg ?? []).length;
+      for (const e of (c.ddg ?? []) as Array<{ prov: string[] }>) {
+        ddgTotal++;
+        if (e.prov.includes("reaching-defs")) ddgReaching++;
+      }
+    }
+    expect(cfg).toBeGreaterThan(0);
+    expect(ddgTotal).toBeGreaterThan(0);
+    expect(ddgReaching).toBe(ddgTotal); // no points-to edges without the oracle
+  });
+
+  test("L3 omits the L4 SDG family (no param_in/param_out/summary/synthetic vertices)", () => {
+    expect(dfL3.application.param_in).toEqual([]);
+    expect(dfL3.application.param_out).toEqual([]);
+    for (const c of allCallables(dfL3.application)) {
+      expect(c.summary ?? []).toEqual([]);
+      for (const k of Object.keys(c.body)) {
+        expect(k.startsWith("@formal")).toBe(false);
+        expect(k.includes("actual")).toBe(false);
+      }
+    }
+  });
+
+  test("no dangling endpoints at L3", () => {
+    expect(danglingCount(dfL3)).toBe(0);
+  });
+});
+
+describe("schema v2 — L4 interprocedural SDG", () => {
+  test("max_level is 4; synthetic formal/actual vertices and param/summary edges appear", () => {
+    expect(dfL4.max_level).toBe(4);
+    let formalIn = 0;
+    let actual = 0;
+    let summary = 0;
+    for (const c of allCallables(dfL4.application)) {
+      for (const k of Object.keys(c.body)) {
+        if (k.startsWith("@formal_in")) formalIn++;
+        if (k.includes("actual")) actual++;
+      }
+      summary += (c.summary ?? []).length;
+    }
+    expect(formalIn).toBeGreaterThan(0);
+    expect(actual).toBeGreaterThan(0);
+    expect(summary).toBeGreaterThan(0);
+    expect(dfL4.application.param_in.length).toBeGreaterThan(0);
+    expect(dfL4.application.param_out.length).toBeGreaterThan(0);
+  });
+
+  test("param_in/param_out use fully-qualified canId@local ids", () => {
+    // Every endpoint is a fully-qualified can:// id with a @local suffix (arg edges AND global-flow edges).
+    for (const e of [...dfL4.application.param_in, ...dfL4.application.param_out]) {
+      for (const ep of [e.src, e.dst]) {
+        expect(ep.startsWith("can://typescript/")).toBe(true);
+        expect(ep.includes("@")).toBe(true);
+      }
+    }
+    // The canonical arg/return shape is present: actual_in→formal_in and formal_out→actual_out.
+    expect(dfL4.application.param_in.some((e) => e.dst.includes("@formal_in:"))).toBe(true);
+    expect(dfL4.application.param_out.some((e) => e.src.includes("@formal_out"))).toBe(true);
+    expect(dfL4.application.param_out.some((e) => e.dst.includes("/actual_out"))).toBe(true);
+  });
+
+  test("no dangling endpoints at L4", () => {
+    expect(danglingCount(dfL4)).toBe(0);
+  });
+
+  test("no null values except the sanctioned call-node callee (canonical § Conventions)", () => {
+    let total = 0;
+    let callee = 0;
+    const walk = (v: unknown, key: string): void => {
+      if (v === null) {
+        total++;
+        if (key === "callee") callee++;
+        return;
+      }
+      if (Array.isArray(v)) {
+        for (const x of v) walk(x, key);
+        return;
+      }
+      if (v && typeof v === "object") for (const [k, val] of Object.entries(v)) walk(val, k);
+    };
+    walk(dfL4, "");
+    expect(total - callee).toBe(0); // absence encodes "no fact"; only callee:null is sanctioned
+  });
+
+  test("monotonicity: every L3 body key and cfg/cdg/ddg edge survives into L4", () => {
+    const key = (c: V2Callable, list: "cfg" | "cdg" | "ddg"): Set<string> =>
+      new Set((c[list] ?? []).map((e: { src: string; dst: string; kind?: string; var?: string }) => `${e.src}>${e.dst}:${e.kind ?? e.var ?? ""}`));
+    const l4 = new Map(allCallables(dfL4.application).map((c) => [c.id, c]));
+    let violations = 0;
+    for (const c3 of allCallables(dfL3.application)) {
+      const c4 = l4.get(c3.id);
+      if (!c4) {
+        violations++;
+        continue;
+      }
+      const body4 = new Set(Object.keys(c4.body));
+      for (const k of Object.keys(c3.body)) if (!body4.has(k)) violations++;
+      for (const list of ["cfg", "cdg", "ddg"] as const) {
+        const e4 = key(c4, list);
+        for (const e of key(c3, list)) if (!e4.has(e)) violations++;
+      }
+    }
+    expect(violations).toBe(0);
+  });
+});
diff --git a/test/synthesized-nodes.test.ts b/test/synthesized-nodes.test.ts
index 21fe613..f250f16 100644
--- a/test/synthesized-nodes.test.ts
+++ b/test/synthesized-nodes.test.ts
@@ -1,40 +1,55 @@
 /**
- * Issue #13: Jelly's synthesized anonymous-callback signatures must materialize as nodes, so their
- * CALLS edges resolve instead of being silently dropped by the MATCH-based Cypher writer.
+ * Issue #13 (schema v2): Jelly's synthesized anonymous-callback signatures must materialize as
+ * graph nodes so their CALLS edges resolve instead of being silently dropped by the MATCH-based
+ * Cypher writer. Under v2 they are homed as `:CanNode:AnonymousCallable` nodes with an ordinal
+ * `<enclosing-callable-id>@<line>:<col>` id, and the call graph references that id.
  */
 import { describe, expect, test } from "bun:test";
 import { project } from "../src/build/neo4j";
-import { CALL_DEP, type TSApplication, type TSCallable, type TSModule } from "../src/schema";
+import type { AnalysisOptions } from "../src/options";
+import { CALL_DEP, type TSApplication, type TSCallable, type TSModule, type TSSpan } from "../src/schema";
+import { toV2Detailed } from "../src/schema/v2";
 
 const ANON = "src/x.foo:<3:10>";
+const SPAN: TSSpan = { start: [1, 1], end: [5, 1], bytes: [0, 10] };
 
-const callable = (signature: string, name: string): TSCallable => ({ signature, name }) as unknown as TSCallable;
+const callable = (signature: string, name: string): TSCallable =>
+  ({ signature, name, kind: "function", span: SPAN, parameters: [], call_sites: [], inner_callables: {}, inner_classes: {} }) as unknown as TSCallable;
 
 const app: TSApplication = {
-  symbol_table: { "src/x.ts": { functions: { foo: callable("src/x.foo", "foo") } } as unknown as TSModule },
+  symbol_table: {
+    "src/x.ts": {
+      module_name: "src/x", source: "", span: SPAN,
+      functions: { "src/x.foo": callable("src/x.foo", "foo") },
+      classes: {}, interfaces: {}, enums: {}, type_aliases: {}, namespaces: {}, variables: [],
+    } as unknown as TSModule,
+  },
   call_graph: [{ source: "src/x.foo", target: ANON, type: CALL_DEP, weight: 1, provenance: ["jelly"], tags: {} }],
   external_symbols: {},
   synthesized_callables: { [ANON]: { name: "<anonymous>", path: "src/x.ts", start_line: 3, start_column: 10 } },
 };
 
-describe("synthesized anonymous-callable nodes", () => {
-  const rows = project(app, "t");
+const opts = { appName: "t", input: "", analysisLevel: 2 } as unknown as AnalysisOptions;
+const { application, idBySig } = toV2Detailed(app, opts);
+const rows = project(application);
 
-  test("emits an :Symbol:AnonymousCallable node for the synthesized signature", () => {
-    const n = rows.nodes.find((n) => n.value === ANON);
-    expect(n?.labels[0]).toBe("Symbol");
-    expect(n?.labels).toContain("AnonymousCallable");
-    expect(n?.props.start_line).toBe(3);
+const fooId = idBySig.get("src/x.foo") as string;
+const anonId = idBySig.get(ANON) as string;
+
+describe("synthesized anonymous-callable nodes (schema v2)", () => {
+  test("the anonymous callback is homed as an ordinal id under its enclosing callable", () => {
+    expect(anonId).toBe(`${fooId}@3:10`);
   });
 
-  test("the CALLS edge to the anonymous callable survives (was silently dropped before)", () => {
-    const e = rows.edges.find((e) => e.type === "CALLS" && e.to.value === ANON);
-    expect(e?.from.value).toBe("src/x.foo");
+  test("emits a :CanNode:AnonymousCallable node for it", () => {
+    const n = rows.nodes.find((n) => n.value === anonId);
+    expect(n?.labels[0]).toBe("CanNode");
+    expect(n?.labels).toContain("AnonymousCallable");
+    expect(n?.props.start_line).toBe(3);
   });
 
-  test("a DECLARES edge links the host symbol to it (keeps it in the wiped subgraph)", () => {
-    const e = rows.edges.find((e) => e.type === "DECLARES" && e.to.value === ANON);
-    expect(e?.from.value).toBe("src/x.foo");
-    expect(e?.from.label).toBe("Symbol");
+  test("the CALLS edge to the anonymous callable resolves (was silently dropped before)", () => {
+    const e = rows.edges.find((e) => e.type === "CALLS" && e.to.value === anonId);
+    expect(e?.from.value).toBe(fooId);
   });
 });

From b44ca71d23952717a065eef97e7e82c6098a7247 Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Tue, 7 Jul 2026 00:10:45 -0400
Subject: [PATCH 08/32] =?UTF-8?q?test:=20enforce=20real=20L1=E2=8A=86L2?=
 =?UTF-8?q?=E2=8A=86L3=E2=8A=86L4=20monotonicity=20+=20neo4j=E2=86=94json?=
 =?UTF-8?q?=20count=20parity?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Runs analyze() fresh at -a 1/2/3/4 on dataflow-app and asserts each level's
symbol-table id / body-node key / edge key sets are a strict superset of the
level below, plus a full-depth Neo4j projection vs analysis.json count-parity
check. Supersedes the narrower L3->L4-only spot-check with an end-to-end gate
across all four levels.
---
 test/schema-v2.test.ts | 193 +++++++++++++++++++++++++++++++++++++----
 1 file changed, 174 insertions(+), 19 deletions(-)

diff --git a/test/schema-v2.test.ts b/test/schema-v2.test.ts
index 7c85c82..ada1509 100644
--- a/test/schema-v2.test.ts
+++ b/test/schema-v2.test.ts
@@ -11,8 +11,9 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { analyze } from "../src/core";
 import type { AnalysisOptions } from "../src/options";
-import type { TSApplication } from "../src/schema";
-import { type V2Callable, type V2Module, type V2Type, toV2Detailed } from "../src/schema/v2";
+import type { GraphSelector, TSApplication } from "../src/schema";
+import { type V2Application, type V2Callable, type V2Module, type V2Type, toV2Detailed } from "../src/schema/v2";
+import { type GraphRows, project } from "../src/build/neo4j";
 
 const FIXTURE = path.resolve(import.meta.dir, "fixtures/sample-app");
 
@@ -402,24 +403,178 @@ describe("schema v2 — L4 interprocedural SDG", () => {
     expect(total - callee).toBe(0); // absence encodes "no fact"; only callee:null is sanctioned
   });
 
-  test("monotonicity: every L3 body key and cfg/cdg/ddg edge survives into L4", () => {
-    const key = (c: V2Callable, list: "cfg" | "cdg" | "ddg"): Set<string> =>
-      new Set((c[list] ?? []).map((e: { src: string; dst: string; kind?: string; var?: string }) => `${e.src}>${e.dst}:${e.kind ?? e.var ?? ""}`));
-    const l4 = new Map(allCallables(dfL4.application).map((c) => [c.id, c]));
-    let violations = 0;
-    for (const c3 of allCallables(dfL3.application)) {
-      const c4 = l4.get(c3.id);
-      if (!c4) {
-        violations++;
-        continue;
-      }
-      const body4 = new Set(Object.keys(c4.body));
-      for (const k of Object.keys(c3.body)) if (!body4.has(k)) violations++;
-      for (const list of ["cfg", "cdg", "ddg"] as const) {
-        const e4 = key(c4, list);
-        for (const e of key(c3, list)) if (!e4.has(e)) violations++;
+  // The full L1⊆L2⊆L3⊆L4 gate (including this L3→L4 edge/body-key check, plus symbol-table ids,
+  // call_graph, summary, and param_in/param_out) lives below in the dedicated monotonicity
+  // describe block, run end-to-end across all four levels rather than just this one pair.
+});
+
+// ---- Real end-to-end monotonicity gate + Neo4j↔JSON count parity (issue #27) -------------------
+//
+// `analyze()` run fresh at each of `-a 1/2/3/4` on dataflow-app (four full runs — the fixture is
+// small), then the emitted V2Application at each level is reduced to three KEY-sets — symbol-table
+// ids, body-node keys, and edge keys (call_graph / cfg / cdg / ddg / summary / param_in / param_out)
+// — and every level's set must be a superset of the level below (canonical-schema.md's additive
+// invariant). Comparing KEYS (not values) means the one sanctioned value mutation, a `call` node's
+// `callee: null → id` refinement between L1 and L2, needs no special-casing: the body key survives
+// unchanged even though its `callee` value changes.
+
+function optsAt(level: 1 | 2 | 3 | 4): AnalysisOptions {
+  // Mirrors the CLI's own `--graphs` default per level (src/cli.ts): graphs is only consulted once
+  // `analysisLevel >= 3` starts extraction at all, so it's `[]` and inert below that.
+  const graphs: GraphSelector[] = level >= 4 ? ["cfg", "dfg", "pdg", "sdg"] : level === 3 ? ["cfg", "dfg", "pdg"] : [];
+  return { ...options(), input: DF_FIXTURE, analysisLevel: level, graphs };
+}
+
+async function appAt(level: 1 | 2 | 3 | 4): Promise<V2Application> {
+  const cacheDir = fs.mkdtempSync(path.join(os.tmpdir(), "cants-mono-"));
+  try {
+    const v1run = await analyze({ ...optsAt(level), cacheDir });
+    return toV2Detailed(v1run, optsAt(level)).application;
+  } finally {
+    fs.rmSync(cacheDir, { recursive: true, force: true });
+  }
+}
+
+/** Every symbol-table id — module/type/callable/field — recursing through nested scopes. */
+function symbolIds(app: V2Application): Set<string> {
+  const out = new Set<string>();
+  const walkCallable = (c: V2Callable): void => {
+    out.add(c.id);
+    for (const cc of Object.values(c.callables ?? {})) walkCallable(cc);
+    for (const t of Object.values(c.types ?? {})) walkType(t);
+  };
+  const walkType = (t: V2Type): void => {
+    out.add(t.id);
+    for (const c of Object.values(t.callables ?? {})) walkCallable(c);
+    for (const f of Object.values(t.fields ?? {})) out.add(f.id);
+    for (const nested of Object.values(t.types ?? {})) walkType(nested);
+    for (const fn of Object.values(t.functions ?? {})) walkCallable(fn);
+  };
+  for (const m of Object.values(app.application.symbol_table)) {
+    out.add(m.id);
+    for (const t of Object.values(m.types)) walkType(t);
+    for (const c of Object.values(m.functions)) walkCallable(c);
+    for (const f of Object.values(m.fields)) out.add(f.id);
+  }
+  return out;
+}
+
+/** Every body-node key, namespaced by its owning callable id so bare local keys never collide. */
+function bodyKeys(app: V2Application): Set<string> {
+  const out = new Set<string>();
+  for (const c of allCallables(app.application)) {
+    for (const k of Object.keys(c.body)) out.add(`${c.id}::${k}`);
+  }
+  return out;
+}
+
+/** Every edge key: call_graph + param_in/param_out (app scope), cfg/cdg/ddg/summary (per callable). */
+function edgeKeys(app: V2Application): Set<string> {
+  const out = new Set<string>();
+  const root = app.application;
+  for (const e of root.call_graph) out.add(`call_graph::${e.src}>${e.dst}:${[...e.prov].sort().join(",")}`);
+  for (const c of allCallables(root)) {
+    for (const list of ["cfg", "cdg", "ddg", "summary"] as const) {
+      for (const e of (c[list] ?? []) as Array<{ src: string; dst: string; kind?: string; var?: string }>) {
+        out.add(`${c.id}::${list}::${e.src}>${e.dst}:${e.kind ?? e.var ?? ""}`);
       }
     }
-    expect(violations).toBe(0);
+  }
+  for (const list of ["param_in", "param_out"] as const) {
+    for (const e of root[list]) out.add(`${list}::${e.src}>${e.dst}:${e.var ?? ""}`);
+  }
+  return out;
+}
+
+/** Elements of `lo` missing from `hi` — empty means `lo` is a subset of `hi`. */
+function missingFrom(lo: Set<string>, hi: Set<string>): string[] {
+  return [...lo].filter((k) => !hi.has(k));
+}
+
+const monoApp1 = await appAt(1);
+const monoApp2 = await appAt(2);
+const monoApp3 = await appAt(3);
+const monoApp4 = await appAt(4);
+const monoPairs: Array<[V2Application, V2Application, string]> = [
+  [monoApp1, monoApp2, "L1 -> L2"],
+  [monoApp2, monoApp3, "L2 -> L3"],
+  [monoApp3, monoApp4, "L3 -> L4"],
+];
+
+describe("additive monotonicity — real L1 ⊆ L2 ⊆ L3 ⊆ L4 gate (issue #27)", () => {
+  test("fixture sanity: each level actually adds new facts (guards against a vacuous superset)", () => {
+    expect(bodyKeys(monoApp1).size).toBeGreaterThan(0);
+    expect(edgeKeys(monoApp2).size).toBeGreaterThan(0); // call_graph appears at L2
+    expect(edgeKeys(monoApp3).size).toBeGreaterThan(edgeKeys(monoApp2).size); // cfg/cdg/ddg appear at L3
+    expect(edgeKeys(monoApp4).size).toBeGreaterThan(edgeKeys(monoApp3).size); // summary/param_in/out appear at L4
+    expect(bodyKeys(monoApp3).size).toBeGreaterThan(bodyKeys(monoApp2).size); // statements appear at L3
+    expect(bodyKeys(monoApp4).size).toBeGreaterThan(bodyKeys(monoApp3).size); // synthetic vertices appear at L4
+  });
+
+  for (const [lo, hi, label] of monoPairs) {
+    test(`symbol-table ids (module/type/callable/field): ${label}`, () => {
+      expect(missingFrom(symbolIds(lo), symbolIds(hi))).toEqual([]);
+    });
+    test(`body-node keys: ${label}`, () => {
+      expect(missingFrom(bodyKeys(lo), bodyKeys(hi))).toEqual([]);
+    });
+    test(`edge keys (call_graph/cfg/cdg/ddg/summary/param_in/param_out): ${label}`, () => {
+      expect(missingFrom(edgeKeys(lo), edgeKeys(hi))).toEqual([]);
+    });
+  }
+});
+
+// ---- Neo4j ↔ JSON count parity, full depth (issue #27) -----------------------------------------
+//
+// `project()` is a second projection of the SAME v2 tree the JSON path emits, so node/edge counts
+// must line up exactly at `-a 4` (full depth). `RowBuilder` dedupes nodes by (labels[0], id) — every
+// project-owned node shares the "CanNode" label — so the JS-side count must dedupe on id the same
+// way; a plain sum-of-walks would silently diverge from `rows.nodes.length` if two tree positions
+// ever produced the same id (which the L1 identity test elsewhere guards against, but this test
+// doesn't lean on that guarantee holding).
+
+const monoRows: GraphRows = project(monoApp4, "dataflow-app");
+
+function relCount(rows: GraphRows, type: string): number {
+  return rows.edges.filter((e) => e.type === type).length;
+}
+
+/** Every id materialized as a `:CanNode` row: symbol-table ids + body-node fq ids + external/synth. */
+function canNodeIds(app: V2Application): Set<string> {
+  const ids = new Set(symbolIds(app));
+  for (const c of allCallables(app.application)) {
+    for (const k of Object.keys(c.body)) ids.add(k.startsWith("@") ? `${c.id}${k}` : `${c.id}@${k}`);
+  }
+  for (const id of Object.keys(app.application.external_symbols ?? {})) ids.add(id);
+  for (const id of Object.keys(app.application.synthesized_callables ?? {})) ids.add(id);
+  return ids;
+}
+
+describe("neo4j ↔ json count parity — full depth (issue #27)", () => {
+  test("node count: 1 :Application row + every :CanNode id", () => {
+    expect(monoRows.nodes.length).toBe(1 + canNodeIds(monoApp4).size);
+  });
+
+  test("typed overlay relationships match their JSON edge-list length 1:1", () => {
+    const callables = allCallables(monoApp4.application);
+    expect(relCount(monoRows, "CALLS")).toBe(monoApp4.application.call_graph.length);
+    expect(relCount(monoRows, "PARAM_IN")).toBe(monoApp4.application.param_in.length);
+    expect(relCount(monoRows, "PARAM_OUT")).toBe(monoApp4.application.param_out.length);
+    expect(relCount(monoRows, "CFG_NEXT")).toBe(callables.reduce((n, c) => n + (c.cfg?.length ?? 0), 0));
+    expect(relCount(monoRows, "CDG")).toBe(callables.reduce((n, c) => n + (c.cdg?.length ?? 0), 0));
+    expect(relCount(monoRows, "DDG")).toBe(callables.reduce((n, c) => n + (c.ddg?.length ?? 0), 0));
+    expect(relCount(monoRows, "SUMMARY")).toBe(callables.reduce((n, c) => n + (c.summary?.length ?? 0), 0));
+  });
+
+  test("containment relationships (HAS_*/DECLARES) match tree cardinality, not a JSON edge-list", () => {
+    // HAS_MODULE/DECLARES/HAS_METHOD/HAS_FIELD/HAS_BODY_NODE have no JSON edge-list counterpart —
+    // they ARE the containment tree. Every node except :Application and the off-tree External/
+    // AnonymousCallable homes gets exactly one incoming containment edge from its tree parent, so
+    // their total must equal every other CanNode id.
+    const containment = ["HAS_MODULE", "DECLARES", "HAS_METHOD", "HAS_FIELD", "HAS_BODY_NODE"];
+    const containmentEdges = containment.reduce((n, t) => n + relCount(monoRows, t), 0);
+    const externalCount = Object.keys(monoApp4.application.external_symbols ?? {}).length;
+    const synthCount = Object.keys(monoApp4.application.synthesized_callables ?? {}).length;
+    expect(containmentEdges).toBe(canNodeIds(monoApp4).size - externalCount - synthCount);
   });
 });

From b3a6f4ad18a12c7ff81fc090144c88b141dc9fe2 Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Tue, 7 Jul 2026 00:19:45 -0400
Subject: [PATCH 09/32] fix: emit real byte offsets on L3 body nodes so
 span.bytes is sliceable
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

GraphNode carried only line/column, so spanOf() in schema/v2/dataflow.ts
hardcoded bytes:[0,0] for every L3 entry/exit/param/statement node —
module.source.slice(...) on any L3 body node returned "". Add
start_offset/end_offset (UTF-16 char offsets, matching the L1 convention)
to GraphNode, populate them at the single construction site
(dataflow/extract.ts's emitNode, from the owning ts-morph node's
getStart()/getEnd() — the whole callable for entry/exit, the param decl
for param nodes), and have spanOf() use them.
---
 src/dataflow/extract.ts   |  11 ++++++++++-
 src/schema/graphs.ts      |   3 +++
 src/schema/v2/dataflow.ts | Bin 12941 -> 12965 bytes
 test/schema-v2.test.ts    |  10 ++++++++++
 4 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/src/dataflow/extract.ts b/src/dataflow/extract.ts
index 751ad53..d9a02f9 100644
--- a/src/dataflow/extract.ts
+++ b/src/dataflow/extract.ts
@@ -81,7 +81,16 @@ function emitNode(id: number, kind: GraphNode["kind"], ast: Node | null, build:
   const target = ast ?? build.fn; // ENTRY/EXIT carry the whole callable's span
   const s = build.sf.getLineAndColumnAtPos(target.getStart());
   const e = build.sf.getLineAndColumnAtPos(target.getEnd());
-  return { id, kind, start_line: s.line, start_column: s.column, end_line: e.line, end_column: e.column };
+  return {
+    id,
+    kind,
+    start_line: s.line,
+    start_column: s.column,
+    end_line: e.line,
+    end_column: e.column,
+    start_offset: target.getStart(),
+    end_offset: target.getEnd(),
+  };
 }
 
 function hasRestParam(build: FunctionCfgBuild): boolean {
diff --git a/src/schema/graphs.ts b/src/schema/graphs.ts
index 801eb5c..27e02a8 100644
--- a/src/schema/graphs.ts
+++ b/src/schema/graphs.ts
@@ -34,6 +34,9 @@ export interface GraphNode {
   start_column: number;
   end_line: number;
   end_column: number;
+  /** UTF-16 char offsets into the owning module's `source` (same convention as L1 `span.bytes`). */
+  start_offset: number;
+  end_offset: number;
 }
 
 // ----------------------------------------------------------------------------------------------
diff --git a/src/schema/v2/dataflow.ts b/src/schema/v2/dataflow.ts
index e5f7a22a36d99541326dbe109c7e1b26dee5c1ec..f664df9af9dda26d80c20595473825f4074f5713 100644
GIT binary patch
delta 41
rcmeB8U7EVVhfgL?uec<!s3bl=Ev-1UL`NY{FEuX(%G(^kXR87LPACsb

delta 24
fcmZ3Q+MBw;hmYMrN5LRgp?0#YUe@NTd>51fXw(RW

diff --git a/test/schema-v2.test.ts b/test/schema-v2.test.ts
index ada1509..a33584e 100644
--- a/test/schema-v2.test.ts
+++ b/test/schema-v2.test.ts
@@ -344,6 +344,16 @@ describe("schema v2 — L3 intraprocedural dataflow", () => {
   test("no dangling endpoints at L3", () => {
     expect(danglingCount(dfL3)).toBe(0);
   });
+
+  test("a sampled L3 statement node is source-sliceable (span.bytes reproduces its text)", () => {
+    const mod = dfL3.application.symbol_table["src/flow.ts"];
+    const classify = mod.functions.classify as V2Callable;
+    const stmt = classify.body["4:3"];
+    expect(stmt?.kind).toBe("statement");
+    const [s, e] = (stmt as { span: { bytes: [number, number] } }).span.bytes;
+    expect(e).toBeGreaterThan(s);
+    expect(mod.source.slice(s, e)).toBe('let label = "none";');
+  });
 });
 
 describe("schema v2 — L4 interprocedural SDG", () => {

From 791f7307b568774e9a4a15e5994644a05fe1620d Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Tue, 7 Jul 2026 00:28:42 -0400
Subject: [PATCH 10/32] feat: add analyzer{name,version} to the schema-v2
 envelope
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Consumers (the CLDK SDK, tooling correlating multiple analysis.json
artifacts) need to know which analyzer produced a given output and at
what version, independent of schema_version. Add a V2Analyzer{name,
version} type and a required analyzer field on V2Application, populated
from the literal package name and the existing ANALYZER_VERSION constant
(src/utils/version.ts) — the same version stamped into the cache, not a
new hardcoded literal.
---
 src/schema/v2/emit.ts  | 3 +++
 src/schema/v2/model.ts | 7 +++++++
 test/schema-v2.test.ts | 6 ++++++
 3 files changed, 16 insertions(+)

diff --git a/src/schema/v2/emit.ts b/src/schema/v2/emit.ts
index 3f0098b..db70c9e 100644
--- a/src/schema/v2/emit.ts
+++ b/src/schema/v2/emit.ts
@@ -12,6 +12,7 @@
 
 import * as path from "node:path";
 import type { AnalysisOptions } from "../../options";
+import { ANALYZER_VERSION } from "../../utils/version";
 import type {
   TSApplication,
   TSCallable,
@@ -30,6 +31,7 @@ import type { V2Application, V2BodyNode, V2CallEdge, V2Callable, V2External, V2F
 
 const LANGUAGE = "typescript";
 const SCHEMA_VERSION = "2.0.0";
+const ANALYZER_NAME = "codeanalyzer-typescript";
 /** Highest analysis level this emitter populates today (L1 tree, L2 call graph, L3/L4 dataflow). */
 const MAX_IMPLEMENTED = 4;
 
@@ -371,6 +373,7 @@ export function toV2Detailed(app: TSApplication, opts: AnalysisOptions): ToV2Res
     language: LANGUAGE,
     max_level: Math.min(level, MAX_IMPLEMENTED),
     ...(k_limit !== undefined ? { k_limit } : {}),
+    analyzer: { name: ANALYZER_NAME, version: ANALYZER_VERSION },
     application: root,
   };
   return { application, idBySig, collisions, dangling };
diff --git a/src/schema/v2/model.ts b/src/schema/v2/model.ts
index a2a19af..493fee6 100644
--- a/src/schema/v2/model.ts
+++ b/src/schema/v2/model.ts
@@ -25,9 +25,16 @@ export interface V2Application {
   language: string; // "typescript"
   max_level: number; // highest level populated; consumers read this, not key-sniffing
   k_limit?: number; // access-path depth bound for the L3/L4 dataflow (present at L3+)
+  analyzer: V2Analyzer; // which analyzer produced this artifact, and at what version
   application: V2Root;
 }
 
+/** Analyzer identity — lets consumers correlate an `analysis.json` with the tool/version that emitted it. */
+export interface V2Analyzer {
+  name: string; // "codeanalyzer-typescript"
+  version: string; // ANALYZER_VERSION (src/utils/version.ts)
+}
+
 export interface V2Root {
   id: string; // can://<lang>/<app>
   kind: "application";
diff --git a/test/schema-v2.test.ts b/test/schema-v2.test.ts
index a33584e..7bf6463 100644
--- a/test/schema-v2.test.ts
+++ b/test/schema-v2.test.ts
@@ -103,6 +103,12 @@ describe("schema v2 — L1 envelope", () => {
       expect(key).not.toContain("\\");
     }
   });
+
+  test("envelope carries analyzer{name,version}", () => {
+    expect(v2.analyzer?.name).toBe("codeanalyzer-typescript");
+    expect(typeof v2.analyzer?.version).toBe("string");
+    expect(v2.analyzer.version.length).toBeGreaterThan(0);
+  });
 });
 
 describe("schema v2 — L1 identity", () => {

From 48b12377fad0b4e84c9fb027be7c2ed0c212fcbc Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Tue, 7 Jul 2026 00:34:28 -0400
Subject: [PATCH 11/32] fix: correct ANALYZER_VERSION drift and pin envelope
 test to package.json

ANALYZER_VERSION was "0.1.0" while package.json was "0.5.0", so the new
analyzer{name,version} manifest advertised a false version. Bump it to
match, and assert analyzer.version equals package.json's version (imported,
not hardcoded) so future drift fails the schema-v2 gate.
---
 test/schema-v2.test.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/schema-v2.test.ts b/test/schema-v2.test.ts
index 7bf6463..6e151e3 100644
--- a/test/schema-v2.test.ts
+++ b/test/schema-v2.test.ts
@@ -9,6 +9,7 @@ import { describe, expect, test } from "bun:test";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import pkg from "../package.json";
 import { analyze } from "../src/core";
 import type { AnalysisOptions } from "../src/options";
 import type { GraphSelector, TSApplication } from "../src/schema";
@@ -106,8 +107,7 @@ describe("schema v2 — L1 envelope", () => {
 
   test("envelope carries analyzer{name,version}", () => {
     expect(v2.analyzer?.name).toBe("codeanalyzer-typescript");
-    expect(typeof v2.analyzer?.version).toBe("string");
-    expect(v2.analyzer.version.length).toBeGreaterThan(0);
+    expect(v2.analyzer?.version).toBe(pkg.version);
   });
 });
 

From 6078c7e11e39a75683fb43266909cb1cf5e7548f Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Tue, 7 Jul 2026 00:46:27 -0400
Subject: [PATCH 12/32] =?UTF-8?q?fix:=20skip=20the=20call-graph=20(incl.?=
 =?UTF-8?q?=20jelly)=20solve=20at=20-a=201=20=E2=80=94=20the=20result=20is?=
 =?UTF-8?q?=20discarded?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The v2 emitter only reads external_symbols/synthesized_callables and
populates call_graph at level >= 2 (homeExternals/homeSynthesized in
src/schema/v2/emit.ts), so running the full provider solve — including
the heavier Jelly leg — at -a 1 computed a result that was thrown away.
Gate provider.build to analysisLevel >= 2; levels 3/4 already require
>= 2 for callee resolution, so this is safe.
---
 src/core.ts            | 10 +++++++++-
 test/schema-v2.test.ts | 38 +++++++++++++++++++++++++++++++++++++-
 2 files changed, 46 insertions(+), 2 deletions(-)

diff --git a/src/core.ts b/src/core.ts
index 5b67226..177ce9d 100644
--- a/src/core.ts
+++ b/src/core.ts
@@ -29,9 +29,17 @@ export async function analyze(opts: AnalysisOptions): Promise<TSApplication> {
   const extraction = opts.analysisLevel >= 3 ? startExtraction(project, symbol_table, mat.tsConfigFilePath, opts, log) : null;
 
   // Call graph via the selected provider (union of tsc+jelly by default; --tsc-only / jelly opt-in).
+  // Only worth running at level >= 2: the v2 emitter discards call_graph/external_symbols/
+  // synthesized_callables at -a 1 (homeExternals/homeSynthesized in src/schema/v2/emit.ts are
+  // gated to `level >= 2`), so running the solve — including the heavier Jelly leg — at -a 1
+  // would compute a result that's thrown away. Levels 3/4 need the provider for callee
+  // resolution and are always >= 2, so this gate is safe.
   const provider = selectProvider(opts.callGraphProvider);
   log.info(`call graph provider: ${provider.name}`);
-  const cg = provider.build({ project, symbol_table, root: opts.input, log, phantoms: opts.phantoms });
+  const cg =
+    opts.analysisLevel >= 2
+      ? provider.build({ project, symbol_table, root: opts.input, log, phantoms: opts.phantoms })
+      : { edges: [], external_symbols: {}, synthesized_callables: {} };
   const call_graph = cg.edges;
 
   const app: TSApplication = {
diff --git a/test/schema-v2.test.ts b/test/schema-v2.test.ts
index 6e151e3..d1ccbdf 100644
--- a/test/schema-v2.test.ts
+++ b/test/schema-v2.test.ts
@@ -5,7 +5,7 @@
  * bindings as module `fields{}`, and `body` `call` nodes at L1 — while remaining a superset of
  * every v1 symbol-table fact.
  */
-import { describe, expect, test } from "bun:test";
+import { describe, expect, spyOn, test } from "bun:test";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -15,6 +15,7 @@ import type { AnalysisOptions } from "../src/options";
 import type { GraphSelector, TSApplication } from "../src/schema";
 import { type V2Application, type V2Callable, type V2Module, type V2Type, toV2Detailed } from "../src/schema/v2";
 import { type GraphRows, project } from "../src/build/neo4j";
+import { tscProvider } from "../src/semantic_analysis";
 
 const FIXTURE = path.resolve(import.meta.dir, "fixtures/sample-app");
 
@@ -188,6 +189,41 @@ describe("schema v2 — L1 superset", () => {
   });
 });
 
+// ---- L1: the call-graph solve is skipped entirely (issue #31) -------------------------------
+// The solve (including the heavier Jelly leg) is only useful from L2 up — the v2 emitter never
+// reads call_graph/external_symbols/synthesized_callables at L1 (homeExternals/homeSynthesized
+// are gated to `level >= 2` in src/schema/v2/emit.ts). This locks BOTH the output invariant
+// (already true before the -a 1 gating fix) AND, via a spy, that the provider itself is skipped.
+describe("schema v2 — L1 skips the call-graph solve (issue #31)", () => {
+  test("provider.build is not invoked and no call-graph/external/synth data appears at -a 1", async () => {
+    const spy = spyOn(tscProvider, "build");
+    const cacheDir = fs.mkdtempSync(path.join(os.tmpdir(), "cants-v2-l1-guard-"));
+    try {
+      const v1L1 = await analyze({ ...options(), analysisLevel: 1, callGraphProvider: "tsc", cacheDir });
+      expect(spy).not.toHaveBeenCalled();
+      expect(v1L1.call_graph).toEqual([]);
+      expect(Object.keys(v1L1.external_symbols)).toEqual([]);
+      expect(Object.keys(v1L1.synthesized_callables)).toEqual([]);
+    } finally {
+      spy.mockRestore();
+      fs.rmSync(cacheDir, { recursive: true, force: true });
+    }
+  });
+
+  test("provider.build IS invoked at -a 2, and produces edges (baseline: L2 unaffected)", async () => {
+    const spy = spyOn(tscProvider, "build");
+    const cacheDir = fs.mkdtempSync(path.join(os.tmpdir(), "cants-v2-l1-guard-l2-"));
+    try {
+      const v1L2guard = await analyze({ ...options(), analysisLevel: 2, callGraphProvider: "tsc", cacheDir });
+      expect(spy).toHaveBeenCalledTimes(1);
+      expect(v1L2guard.call_graph.length).toBeGreaterThan(0);
+    } finally {
+      spy.mockRestore();
+      fs.rmSync(cacheDir, { recursive: true, force: true });
+    }
+  });
+});
+
 // ---- L2: call graph -------------------------------------------------------------------------
 async function runL2(): Promise<TSApplication> {
   const cacheDir = fs.mkdtempSync(path.join(os.tmpdir(), "cants-v2-l2-"));

From 8ad9234302f97563c0ac5eb03749e1a7717d5214 Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Tue, 7 Jul 2026 00:52:06 -0400
Subject: [PATCH 13/32] chore: sanction reaching-defs as an additive ddg prov
 token (schema decisions + neo4j lockstep)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Strengthens the code comment at src/schema/v2/dataflow.ts to record that
"reaching-defs" is a deliberate, sanctioned additive DDG prov token — a
documented deviation from the canonical "ssa" tag — accepted across
JSON, Neo4j (open string[] property, no enum), and the SDK. Full
rationale recorded in .claude/SCHEMA_DECISIONS.md (gitignored, local-
only). No emitter behavior change: the token stays "reaching-defs" and
test/schema-v2.test.ts's assertion is untouched.
---
 src/schema/v2/dataflow.ts | Bin 12965 -> 13360 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/src/schema/v2/dataflow.ts b/src/schema/v2/dataflow.ts
index f664df9af9dda26d80c20595473825f4074f5713..784c548e60d47e7d35cd14042a5c0774074756bb 100644
GIT binary patch
delta 367
zcmYjNy-or_5RR6<00kCb&O%7|iDIP{@rXgqkqEI-lN)x2yVbj0vb#ru4Yt<$3ic$v
zk*zP`f)-9SGx_HGnGas)>!aGL+eKuVM6Pt!mOOJ2lmlVhPtGU9Q8I|pkK^HFcssz{
zngzUhVvVnt_W+Vys3}|W+=4WsDp`A$VZBh~mC<|ntDrKori9NKE+-p6!W!q=_oS&<
zKC{Kb2%1&}+2x^wAZ@e~R3LJWB6!L$Gj@A_-Gf_dPr@sKIKJroSGi$ftPJ!@BYpec
zt*=rvlyep1pm*Fn!{vCCw2-hlc|;?XGV5$oox*t=K5+Mtw*J#;<3Sp%tFqY&o!mMY
j$5$v#2#>OI0Z<emA$abgHj~krQ<8tJ?{q)+Yp?YmHM4fE

delta 12
Tcmdmxu{3pqq4?%K5+%|ACEf)w


From a0d154f846c18d7a3b6eab01820ff5453d378534 Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Tue, 7 Jul 2026 01:18:16 -0400
Subject: [PATCH 14/32] feat: project class inheritance as EXTENDS/IMPLEMENTS
 neo4j relationships

Resolves each type's heritage signatures (base_classes/implements_types)
through idBySig to can:// ids in the v2 emitter, dropping unresolved
external/library supertypes rather than nulling them. Exposes the result
as extends_ids/implements_ids on the V2 type node (JSON props unchanged)
and projects them as EXTENDS/IMPLEMENTS relationships in Neo4j via the
previously-dead RowBuilder.edgeToSymbol deferred gate, which was also
re-pointed at the correct CanNode/id addressing (it had been hardcoded to
a Symbol/signature pair no node in the v2 schema actually carries).

Adds a first-party class hierarchy fixture to dataflow-app and extends
both the schema conformance test and the issue #27 Neo4j<->JSON parity
gate (the latter now also has an exhaustive total-edge accounting test).
---
 schema.neo4j.json                           |  23 ++++
 src/build/neo4j/project.ts                  |   4 +
 src/build/neo4j/rows.ts                     | Bin 5952 -> 5810 bytes
 src/build/neo4j/schema.ts                   |   6 +
 src/schema/v2/emit.ts                       |  36 +++++-
 src/schema/v2/model.ts                      |   5 +
 test/fixtures/dataflow-app/src/hierarchy.ts |  28 +++++
 test/neo4j-schema.test.ts                   |  41 +++++++
 test/schema-v2.test.ts                      | 122 +++++++++++++++++++-
 9 files changed, 261 insertions(+), 4 deletions(-)
 create mode 100644 test/fixtures/dataflow-app/src/hierarchy.ts

diff --git a/schema.neo4j.json b/schema.neo4j.json
index 0680b8e..2fb9054 100644
--- a/schema.neo4j.json
+++ b/schema.neo4j.json
@@ -372,6 +372,29 @@
       "properties": {
         "var": "string"
       }
+    },
+    {
+      "type": "EXTENDS",
+      "from": [
+        "Class",
+        "Interface"
+      ],
+      "to": [
+        "Class",
+        "Interface"
+      ],
+      "properties": {}
+    },
+    {
+      "type": "IMPLEMENTS",
+      "from": [
+        "Class"
+      ],
+      "to": [
+        "Interface",
+        "Class"
+      ],
+      "properties": {}
     }
   ],
   "constraints": [
diff --git a/src/build/neo4j/project.ts b/src/build/neo4j/project.ts
index 5077178..7c59e54 100644
--- a/src/build/neo4j/project.ts
+++ b/src/build/neo4j/project.ts
@@ -96,6 +96,10 @@ function projectType(b: RowBuilder, t: V2Type, parent: NodeRef, fileKey: string)
   const label = KIND_LABEL[t.kind] ?? "Class";
   const node = b.node([CAN, label], "id", t.id, typeProps(t, fileKey));
   b.edge("DECLARES", parent, node);
+  // Inheritance overlay — resolved-only (emit.ts already dropped unresolved/external supertypes);
+  // the deferred gate is defense-in-depth against a resolved id that never materialized as a node.
+  for (const eid of t.extends_ids ?? []) b.edgeToSymbol("EXTENDS", node, eid);
+  for (const iid of t.implements_ids ?? []) b.edgeToSymbol("IMPLEMENTS", node, iid);
   if (t.kind === "namespace") {
     projectScope(b, t, node, fileKey); // a namespace nests types/functions/fields
     return;
diff --git a/src/build/neo4j/rows.ts b/src/build/neo4j/rows.ts
index 73d085a30ff19c0f6611709bb58cd3e90ff3ce38..f7900e946b464045d4b302e270ef4dc8f0403cad 100644
GIT binary patch
delta 524
zcmYL`v2GJV5QfDSL^9xrmg<)aa3bHiqOqYs$tkjgFA;G;5s4dnCwB{XyQkf;rK1TY
zC6alND1HH6fS2G&Slc0#qxok3fByNE+{L%^=w?<jd`XTKrs;>X6cx?6!nJka6}uMs
zg3M?*%ww(MFWd&sSjFhq+Bxey^2XWEypTkE{wkCw@3I^VYrK$=qXfsp&aOgee9F#G
zQ@lm*giIE;^v0X3$UNR0be=xiyngaMD*lT>$Q3N;b5bNAIQF($1$n=0*h$;)5u_wR
zt&38EDM3jqMoq#_Q>DMM>Hs(f`7pjSEv5EwOOvdhbzeqWt>1KC-0Y!zbnht-TlW<H
zeESJ+k$#+|+36*Qm`pF;r_(f>UBYbBfg)2>Aq)vAYK1UIm19!vgWcGgs>QtBt86*Z
zb$}%hv?$q6P_pCkUNtP(B8sosc#gG+6*p3%2uBTeH*VXF(=~<H>>^o;wgz6fS^w^i
nqlsESKh*tyVGj^~cHwL@LQkvS04u7NJh~5eqBggOKMwu^U%#&T

delta 663
zcmX|8&59F25XKyoUD);D$%9bjpoy5-#e;{06%ps4Y<7bQt01B^Gqss^d%BzMnq&u&
z^#ueaK8TnX&{y%|YgjWAbLfVy`nu}-`8oI%{YX0Nzn%R0)f0yv3!qDfCIjnOS%Vrh
zCZq>}c+(*d=$uxR0b8I2`3j89=w4`{0eYMhgfyoDrBspM1%UgY%m+$2fRe*YWd_Y;
za8|3dg8Yg+jlkPwh*}Woa|n!8*vuN>+}OY>?ME;!1H%Q81KHJ%FUZfSr2xpXEu%{~
zjGE?w+^IEzeVMZLJ?GT|nZOff*66C1_E1z0q1TWKL)q+=nZJ44hoi^a2OJ5YsmT5D
z)B5So?Q3`1AJXDng{ZY}Gp0XUpY49>Oor2{NUVMjj6#wHDGUp&AR$@J<i+R%trCx7
zW-4ZiqYTbdAX7`JRl?k(%UeCG7khVK1vNLwr6*Wo08F_=T}vqxvxHOEnqc71=kE|K
z#II-Z$+IccW=I^*$CKlD9G}dj0x#p~>G4@SeK$K@{ocEE*s6zfnV4XD0a`66fNhBc
zTl%!7*o5x9bzwEzAMH&46Iy-SSC6`_=I#T@shS9A2;D7ZsV-2LG~76{{krbn{CeXb
DSzF}M

diff --git a/src/build/neo4j/schema.ts b/src/build/neo4j/schema.ts
index 5cad335..8c43efc 100644
--- a/src/build/neo4j/schema.ts
+++ b/src/build/neo4j/schema.ts
@@ -150,6 +150,12 @@ export const REL_TYPES: RelType[] = [
   { type: "SUMMARY", from: ["BodyNode"], to: ["BodyNode"], properties: { var: "string" } },
   { type: "PARAM_IN", from: ["BodyNode"], to: ["BodyNode"], properties: { var: "string" } },
   { type: "PARAM_OUT", from: ["BodyNode"], to: ["BodyNode"], properties: { var: "string" } },
+  // Inheritance, projected from the `extends_ids`/`implements_ids` node props (schema/v2/emit.ts) —
+  // resolved-only: an unresolved (external/library) supertype never reaches here. A `to` of `Class`
+  // covers TS's `implements SomeClass` (structural, not just interfaces); an interface may itself
+  // `extends` a class's instance type, hence `EXTENDS` also allows an `Interface` source.
+  { type: "EXTENDS", from: ["Class", "Interface"], to: ["Class", "Interface"], properties: {} },
+  { type: "IMPLEMENTS", from: ["Class"], to: ["Interface", "Class"], properties: {} },
 ];
 
 // ----------------------------------------------------------------------------------------------
diff --git a/src/schema/v2/emit.ts b/src/schema/v2/emit.ts
index db70c9e..3dfe880 100644
--- a/src/schema/v2/emit.ts
+++ b/src/schema/v2/emit.ts
@@ -111,11 +111,19 @@ function memberKey(sig: string, accessorKind?: string | null): string {
   return seg;
 }
 
+/** A type's heritage signatures, resolved to `can://` ids once the whole tree walk registers them. */
+interface PendingHeritage {
+  node: V2Type;
+  extendsSigs: string[]; // class: the extended base class; interface: extended interface(s)
+  implementsSigs: string[]; // class only: implemented interfaces
+}
+
 /** State shared across the whole tree walk (edge-rewriting + gating). */
 interface SharedState {
   idBySig: Map<string, string>;
   collisions: string[];
   pendingCallees: Array<{ node: V2BodyNode; calleeSig: string | null }>; // backfilled at L2
+  pendingHeritage: PendingHeritage[]; // resolved sig→id once the whole tree walk completes
   callableBySig: Map<string, V2Callable>; // locates each callable's node for the L3/L4 dataflow pass
   level: number;
 }
@@ -201,7 +209,14 @@ function toClass(c: TSClass, ctx: Ctx): V2Type {
   const fields: Record<string, V2Field> = {};
   for (const [name, a] of Object.entries(c.attributes ?? {}))
     fields[name] = fieldNode(id, name, (a as TSClassAttribute).span, a as unknown as Record<string, unknown>);
-  return { ...carry(c as unknown as Record<string, unknown>), id, kind: "class", signature: c.signature, span: c.span, callables, fields };
+  const node: V2Type = { ...carry(c as unknown as Record<string, unknown>), id, kind: "class", signature: c.signature, span: c.span, callables, fields };
+  // `base_classes` is the union of extends + implements (schema.ts:231); subtract implements_types
+  // to recover just the extended base class (0 or 1 — TS classes extend at most one class).
+  if (c.base_classes.length) {
+    const extendsSigs = c.base_classes.filter((s) => !c.implements_types.includes(s));
+    ctx.pendingHeritage.push({ node, extendsSigs, implementsSigs: c.implements_types });
+  }
+  return node;
 }
 
 function toInterface(i: TSInterface, ctx: Ctx): V2Type {
@@ -212,7 +227,11 @@ function toInterface(i: TSInterface, ctx: Ctx): V2Type {
   const fields: Record<string, V2Field> = {};
   for (const [name, p] of Object.entries(i.properties ?? {}))
     fields[name] = fieldNode(id, name, (p as TSClassAttribute).span, p as unknown as Record<string, unknown>);
-  return { ...carry(i as unknown as Record<string, unknown>), id, kind: "interface", signature: i.signature, span: i.span, callables, fields };
+  const node: V2Type = { ...carry(i as unknown as Record<string, unknown>), id, kind: "interface", signature: i.signature, span: i.span, callables, fields };
+  // Interface heritage is extends-only (schema.ts:255) — an interface can extend other interfaces
+  // (or, rarely, a class's instance type), but never "implements".
+  if (i.base_classes.length) ctx.pendingHeritage.push({ node, extendsSigs: i.base_classes, implementsSigs: [] });
+  return node;
 }
 
 function toEnum(e: TSEnum, ctx: Ctx): V2Type {
@@ -332,8 +351,9 @@ export function toV2Detailed(app: TSApplication, opts: AnalysisOptions): ToV2Res
   const idBySig = new Map<string, string>();
   const collisions: string[] = [];
   const pendingCallees: Array<{ node: V2BodyNode; calleeSig: string | null }> = [];
+  const pendingHeritage: PendingHeritage[] = [];
   const callableBySig = new Map<string, V2Callable>();
-  const shared: SharedState = { idBySig, collisions, pendingCallees, callableBySig, level };
+  const shared: SharedState = { idBySig, collisions, pendingCallees, pendingHeritage, callableBySig, level };
 
   // L1 — the containment tree (registers every real callable/type id in idBySig).
   const symbol_table: Record<string, V2Module> = {};
@@ -342,6 +362,16 @@ export function toV2Detailed(app: TSApplication, opts: AnalysisOptions): ToV2Res
   }
   const root: V2Root = { id: appId, kind: "application", symbol_table, call_graph: [], param_in: [], param_out: [] };
 
+  // Resolve heritage sig → can:// id now that every first-party type is registered in idBySig
+  // (independent of level: types are homed during the unconditional L1 walk above). Unresolved
+  // (external/library) supertypes are dropped, never nulled — the "resolved-only" rule.
+  for (const { node, extendsSigs, implementsSigs } of pendingHeritage) {
+    const extendsIds = extendsSigs.map((s) => idBySig.get(s)).filter((x): x is string => x !== undefined);
+    const implementsIds = implementsSigs.map((s) => idBySig.get(s)).filter((x): x is string => x !== undefined);
+    if (extendsIds.length) node.extends_ids = extendsIds;
+    if (implementsIds.length) node.implements_ids = implementsIds;
+  }
+
   // L2 — home the off-tree edge endpoints, backfill `callee`, rewrite the call graph.
   const dangling: string[] = [];
   if (level >= 2) {
diff --git a/src/schema/v2/model.ts b/src/schema/v2/model.ts
index 493fee6..ecf04f6 100644
--- a/src/schema/v2/model.ts
+++ b/src/schema/v2/model.ts
@@ -102,6 +102,11 @@ export interface V2Type extends V2Node {
   fields?: Record<string, V2Field>; // class attributes / interface properties / enum members
   types?: Record<string, V2Type>; // namespace: nested types
   functions?: Record<string, V2Callable>; // namespace: nested functions
+  // Heritage: `base_classes`/`implements_types` (carried from v1) stay signature strings — the
+  // resolved-id projection lives here, additively, for the Neo4j EXTENDS/IMPLEMENTS overlay.
+  // External/library supertypes that never resolve to a first-party id are dropped, not nulled.
+  extends_ids?: string[]; // resolved `can://` id(s) of the extended class/interface(s)
+  implements_ids?: string[]; // resolved `can://` id(s) of implemented interfaces (classes only)
 }
 
 export interface V2Callable extends V2Node {
diff --git a/test/fixtures/dataflow-app/src/hierarchy.ts b/test/fixtures/dataflow-app/src/hierarchy.ts
new file mode 100644
index 0000000..79da20e
--- /dev/null
+++ b/test/fixtures/dataflow-app/src/hierarchy.ts
@@ -0,0 +1,28 @@
+/** A minimal first-party class hierarchy — exercises the Neo4j EXTENDS/IMPLEMENTS projection. */
+
+export interface Shape {
+  area(): number;
+}
+
+export interface Labeled {
+  readonly label: string;
+}
+
+export class Rectangle implements Shape {
+  constructor(
+    protected readonly width: number,
+    protected readonly height: number,
+  ) {}
+
+  area(): number {
+    return this.width * this.height;
+  }
+}
+
+export class Square extends Rectangle implements Labeled {
+  readonly label = "square";
+
+  constructor(side: number) {
+    super(side, side);
+  }
+}
diff --git a/test/neo4j-schema.test.ts b/test/neo4j-schema.test.ts
index 389e766..c22e139 100644
--- a/test/neo4j-schema.test.ts
+++ b/test/neo4j-schema.test.ts
@@ -91,3 +91,44 @@ describe("neo4j schema conformance", () => {
     expect(onDisk).toBe(fresh);
   });
 });
+
+// ---- Class inheritance: EXTENDS/IMPLEMENTS (issue #33) ------------------------------------------
+// dataflow-app's src/hierarchy.ts is a minimal, first-party heritage fixture: `Rectangle implements
+// Shape`, `Square extends Rectangle implements Labeled`.
+
+describe("neo4j inheritance edges (issue #33)", () => {
+  test("EXTENDS and IMPLEMENTS are declared in the schema catalog", () => {
+    expect(relByType.has("EXTENDS")).toBe(true);
+    expect(relByType.has("IMPLEMENTS")).toBe(true);
+  });
+
+  function nodeBySignature(signature: string) {
+    return rows.nodes.find((n) => n.props.signature === signature);
+  }
+
+  test("hierarchy.ts's first-party heritage projects the expected, non-dangling EXTENDS/IMPLEMENTS edges", () => {
+    const square = nodeBySignature("src/hierarchy.Square");
+    const rectangle = nodeBySignature("src/hierarchy.Rectangle");
+    const shape = nodeBySignature("src/hierarchy.Shape");
+    const labeled = nodeBySignature("src/hierarchy.Labeled");
+    expect(square, "Square node").toBeDefined();
+    expect(rectangle, "Rectangle node").toBeDefined();
+    expect(shape, "Shape node").toBeDefined();
+    expect(labeled, "Labeled node").toBeDefined();
+
+    const ext = rows.edges.filter((e) => e.type === "EXTENDS");
+    const impl = rows.edges.filter((e) => e.type === "IMPLEMENTS");
+    expect(ext.length).toBeGreaterThan(0);
+    expect(impl.length).toBeGreaterThan(0);
+
+    expect(ext.some((e) => e.from.value === square!.value && e.to.value === rectangle!.value)).toBe(true);
+    expect(impl.some((e) => e.from.value === rectangle!.value && e.to.value === shape!.value)).toBe(true);
+    expect(impl.some((e) => e.from.value === square!.value && e.to.value === labeled!.value)).toBe(true);
+
+    const nodeValues = new Set(rows.nodes.map((n) => n.value));
+    for (const e of [...ext, ...impl]) {
+      expect(nodeValues.has(e.from.value), `dangling EXTENDS/IMPLEMENTS source ${e.from.value}`).toBe(true);
+      expect(nodeValues.has(e.to.value), `dangling EXTENDS/IMPLEMENTS target ${e.to.value}`).toBe(true);
+    }
+  });
+});
diff --git a/test/schema-v2.test.ts b/test/schema-v2.test.ts
index d1ccbdf..830f838 100644
--- a/test/schema-v2.test.ts
+++ b/test/schema-v2.test.ts
@@ -170,6 +170,58 @@ describe("schema v2 — L1 tree shape", () => {
   });
 });
 
+// ---- Inheritance: heritage signatures resolve to can:// ids (issue #33) ------------------------
+// sample-app's models.ts is first-party heritage: Entity implements Identifiable; User extends
+// Entity implements Named; Robot implements Named (a second, unrelated implementer of Named).
+// This resolution is unconditional (independent of `-a` level) — it only needs idBySig, which the
+// unconditional L1 tree walk already populates — so it's exercised here even though `st` is L1.
+describe("schema v2 — inheritance resolves heritage signatures to can:// ids (issue #33)", () => {
+  test("a class's extends/implements signatures resolve to their declaring node's id", () => {
+    const types = st["src/models.ts"].types;
+    const entity = types.Entity;
+    const user = types.User;
+    const robot = types.Robot;
+    const identifiable = types.Identifiable;
+    const named = types.Named;
+
+    expect(entity.extends_ids).toBeUndefined(); // no base class, only `implements`
+    expect(entity.implements_ids).toEqual([identifiable.id]);
+
+    expect(user.extends_ids).toEqual([entity.id]);
+    expect(user.implements_ids).toEqual([named.id]);
+
+    expect(robot.extends_ids).toBeUndefined();
+    expect(robot.implements_ids).toEqual([named.id]);
+  });
+
+  test("base_classes/implements_types (signature strings) are unchanged — additive, not replaced", () => {
+    const entity = st["src/models.ts"].types.Entity as unknown as { base_classes: string[]; implements_types: string[] };
+    const user = st["src/models.ts"].types.User as unknown as { base_classes: string[]; implements_types: string[] };
+    const identifiableSig = st["src/models.ts"].types.Identifiable.signature;
+    const entitySig = st["src/models.ts"].types.Entity.signature;
+    const namedSig = st["src/models.ts"].types.Named.signature;
+
+    expect(entity.base_classes).toEqual([identifiableSig]);
+    expect(entity.implements_types).toEqual([identifiableSig]);
+    expect(user.base_classes).toEqual([entitySig, namedSig]);
+    expect(user.implements_types).toEqual([namedSig]);
+  });
+
+  test("an unresolved (external/library) supertype is dropped, not nulled", () => {
+    // Every type in sample-app either has no heritage or fully first-party heritage, so there is no
+    // dropped entry to observe directly here — instead assert the shape invariant the resolver
+    // relies on: extends_ids/implements_ids, when present, are always non-empty arrays of can://
+    // ids (never contain undefined/null placeholders for an unresolved signature).
+    for (const t of Object.values(st["src/models.ts"].types)) {
+      for (const ids of [t.extends_ids, t.implements_ids]) {
+        if (ids === undefined) continue;
+        expect(ids.length).toBeGreaterThan(0);
+        for (const id of ids) expect(id.startsWith("can://")).toBe(true);
+      }
+    }
+  });
+});
+
 describe("schema v2 — L1 superset", () => {
   test("every v1 callable/type signature has a v2 id", () => {
     const v1sigs = new Set<string>();
@@ -511,6 +563,26 @@ function symbolIds(app: V2Application): Set<string> {
   return out;
 }
 
+/** Every type node — classes/interfaces/enums/aliases/namespaces — recursing through nested scopes. */
+function allTypes(app: V2Application): V2Type[] {
+  const out: V2Type[] = [];
+  const walkCallable = (c: V2Callable): void => {
+    for (const cc of Object.values(c.callables ?? {})) walkCallable(cc);
+    for (const t of Object.values(c.types ?? {})) walkType(t);
+  };
+  const walkType = (t: V2Type): void => {
+    out.push(t);
+    for (const c of Object.values(t.callables ?? {})) walkCallable(c);
+    for (const nested of Object.values(t.types ?? {})) walkType(nested);
+    for (const fn of Object.values(t.functions ?? {})) walkCallable(fn);
+  };
+  for (const m of Object.values(app.application.symbol_table)) {
+    for (const t of Object.values(m.types)) walkType(t);
+    for (const c of Object.values(m.functions)) walkCallable(c);
+  }
+  return out;
+}
+
 /** Every body-node key, namespaced by its owning callable id so bare local keys never collide. */
 function bodyKeys(app: V2Application): Set<string> {
   const out = new Set<string>();
@@ -602,6 +674,15 @@ function canNodeIds(app: V2Application): Set<string> {
   return ids;
 }
 
+/** Every `call` body node whose `callee` resolved to an id — the JSON-side source of RESOLVES_TO. */
+function resolvesToCount(app: V2Application): number {
+  let n = 0;
+  for (const c of allCallables(app.application)) {
+    for (const bn of Object.values(c.body)) if (typeof bn.callee === "string") n++;
+  }
+  return n;
+}
+
 describe("neo4j ↔ json count parity — full depth (issue #27)", () => {
   test("node count: 1 :Application row + every :CanNode id", () => {
     expect(monoRows.nodes.length).toBe(1 + canNodeIds(monoApp4).size);
@@ -622,11 +703,50 @@ describe("neo4j ↔ json count parity — full depth (issue #27)", () => {
     // HAS_MODULE/DECLARES/HAS_METHOD/HAS_FIELD/HAS_BODY_NODE have no JSON edge-list counterpart —
     // they ARE the containment tree. Every node except :Application and the off-tree External/
     // AnonymousCallable homes gets exactly one incoming containment edge from its tree parent, so
-    // their total must equal every other CanNode id.
+    // their total must equal every other CanNode id. (RESOLVES_TO and EXTENDS/IMPLEMENTS ALSO have
+    // no top-level JSON edge-list — they're sourced from a body node's `callee` and a type node's
+    // `extends_ids`/`implements_ids` props respectively — but they are not containment either, so
+    // they're deliberately excluded from this invariant too; see the dedicated tests below and the
+    // exhaustive edge-accounting test that folds every relationship family back into one total.)
     const containment = ["HAS_MODULE", "DECLARES", "HAS_METHOD", "HAS_FIELD", "HAS_BODY_NODE"];
     const containmentEdges = containment.reduce((n, t) => n + relCount(monoRows, t), 0);
     const externalCount = Object.keys(monoApp4.application.external_symbols ?? {}).length;
     const synthCount = Object.keys(monoApp4.application.synthesized_callables ?? {}).length;
     expect(containmentEdges).toBe(canNodeIds(monoApp4).size - externalCount - synthCount);
   });
+
+  test("EXTENDS/IMPLEMENTS have no JSON edge-list (extends_ids/implements_ids node props are the source of truth); counts still match 1:1", () => {
+    const types = allTypes(monoApp4);
+    const extendsCount = types.reduce((n, t) => n + (t.extends_ids?.length ?? 0), 0);
+    const implementsCount = types.reduce((n, t) => n + (t.implements_ids?.length ?? 0), 0);
+    // sanity: dataflow-app's first-party hierarchy (src/hierarchy.ts) exercises both relationship
+    // kinds — guards against a vacuous 0 === 0 pass if the fixture ever loses its heritage.
+    expect(extendsCount).toBeGreaterThan(0);
+    expect(implementsCount).toBeGreaterThan(0);
+    expect(relCount(monoRows, "EXTENDS")).toBe(extendsCount);
+    expect(relCount(monoRows, "IMPLEMENTS")).toBe(implementsCount);
+  });
+
+  test("every projected edge is accounted for: typed overlay + containment + RESOLVES_TO + EXTENDS/IMPLEMENTS sums to the total", () => {
+    // The exhaustive form of the parity gate: unlike the per-family tests above (which only prove
+    // each family individually matches its JSON source), this proves nothing is left over — if
+    // project.ts ever grows a new relationship family without this test learning about it, the two
+    // sides diverge and the gate fails, instead of silently passing on an incomplete accounting.
+    const typedOverlay =
+      relCount(monoRows, "CALLS") +
+      relCount(monoRows, "PARAM_IN") +
+      relCount(monoRows, "PARAM_OUT") +
+      relCount(monoRows, "CFG_NEXT") +
+      relCount(monoRows, "CDG") +
+      relCount(monoRows, "DDG") +
+      relCount(monoRows, "SUMMARY");
+    const containment = ["HAS_MODULE", "DECLARES", "HAS_METHOD", "HAS_FIELD", "HAS_BODY_NODE"].reduce(
+      (n, t) => n + relCount(monoRows, t),
+      0,
+    );
+    const resolvesTo = relCount(monoRows, "RESOLVES_TO");
+    const heritage = relCount(monoRows, "EXTENDS") + relCount(monoRows, "IMPLEMENTS");
+    expect(resolvesTo).toBe(resolvesToCount(monoApp4));
+    expect(typedOverlay + containment + resolvesTo + heritage).toBe(monoRows.edges.length);
+  });
 });

From 2f866575f81eb04db5934b7be4742d052eea80ba Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Tue, 7 Jul 2026 07:12:35 -0400
Subject: [PATCH 15/32] fix: carry analyzer name+version on the neo4j
 :Application node
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The JSON envelope advertises analyzer{name,version} (#29), but the
Neo4j :Application node had neither — so the two co-primary
projections diverged on analyzer identity. project() now sources
name/version from the same V2Application.analyzer the envelope uses
(populated from ANALYZER_VERSION in src/utils/version.ts), declared
in the schema catalog and regenerated into schema.neo4j.json.
---
 schema.neo4j.json          |  4 +++-
 src/build/neo4j/project.ts |  4 ++++
 src/build/neo4j/schema.ts  |  6 +++++-
 test/neo4j-schema.test.ts  | 14 ++++++++++++++
 4 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/schema.neo4j.json b/schema.neo4j.json
index 2fb9054..e766e83 100644
--- a/schema.neo4j.json
+++ b/schema.neo4j.json
@@ -14,7 +14,9 @@
         "schema_version": "string",
         "language": "string",
         "max_level": "integer",
-        "k_limit": "integer"
+        "k_limit": "integer",
+        "name": "string",
+        "version": "string"
       }
     },
     {
diff --git a/src/build/neo4j/project.ts b/src/build/neo4j/project.ts
index 7c59e54..9a7908f 100644
--- a/src/build/neo4j/project.ts
+++ b/src/build/neo4j/project.ts
@@ -51,6 +51,10 @@ export function project(app: V2Application, _appName?: string): GraphRows {
     language: app.language,
     max_level: app.max_level,
     k_limit: app.k_limit ?? null,
+    // Same analyzer{name,version} the JSON envelope carries (emit.ts) — the two co-primary
+    // projections must never diverge on analyzer identity (issue #43).
+    name: app.analyzer.name,
+    version: app.analyzer.version,
   }));
 
   for (const mod of Object.values(root.symbol_table)) {
diff --git a/src/build/neo4j/schema.ts b/src/build/neo4j/schema.ts
index 8c43efc..4319bc5 100644
--- a/src/build/neo4j/schema.ts
+++ b/src/build/neo4j/schema.ts
@@ -56,7 +56,11 @@ export const NODE_LABELS: NodeLabel[] = [
     label: "Application",
     mergeLabel: "Application",
     key: "id",
-    properties: { id: "string", schema_version: "string", language: "string", max_level: "integer", k_limit: "integer" },
+    properties: {
+      id: "string", schema_version: "string", language: "string", max_level: "integer", k_limit: "integer",
+      // Analyzer identity — mirrors the JSON envelope's `analyzer{name,version}` (issue #43).
+      name: "string", version: "string",
+    },
   },
   {
     label: "Module",
diff --git a/test/neo4j-schema.test.ts b/test/neo4j-schema.test.ts
index c22e139..35aca27 100644
--- a/test/neo4j-schema.test.ts
+++ b/test/neo4j-schema.test.ts
@@ -9,6 +9,7 @@ import { describe, expect, test } from "bun:test";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import pkg from "../package.json";
 import {
   MARKER_LABELS,
   NODE_LABELS,
@@ -92,6 +93,19 @@ describe("neo4j schema conformance", () => {
   });
 });
 
+// ---- :Application analyzer identity (issue #43) ------------------------------------------------
+// The JSON envelope advertises `analyzer{name,version}` (#29); the Neo4j :Application node is the
+// co-primary projection of the same envelope and must not diverge on analyzer identity.
+
+describe(":Application node carries analyzer identity (issue #43)", () => {
+  test("version matches package.json (the same source the JSON envelope's analyzer.version uses)", () => {
+    const appNode = rows.nodes.find((n) => n.labels.includes("Application"));
+    expect(appNode, "no :Application node projected").toBeDefined();
+    expect(appNode!.props.version).toBe(pkg.version);
+    expect(appNode!.props.name).toBe("codeanalyzer-typescript");
+  });
+});
+
 // ---- Class inheritance: EXTENDS/IMPLEMENTS (issue #33) ------------------------------------------
 // dataflow-app's src/hierarchy.ts is a minimal, first-party heritage fixture: `Rectangle implements
 // Shape`, `Square extends Rectangle implements Labeled`.

From 8e30d2761779335a14c873951522ea5069ef5d07 Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Tue, 7 Jul 2026 07:18:58 -0400
Subject: [PATCH 16/32] fix: rename :Application analyzer props to
 analyzer_name/analyzer_version

Bare name/version on :Application collided with project()'s _appName param
and every other CanNode's bare `name`. Namespace analyzer identity the same
way the JSON envelope does (analyzer{name,version}), unambiguous from the
node's own identity fields.
---
 schema.neo4j.json          | 4 ++--
 src/build/neo4j/project.ts | 8 +++++---
 src/build/neo4j/schema.ts  | 6 ++++--
 test/neo4j-schema.test.ts  | 4 ++--
 4 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/schema.neo4j.json b/schema.neo4j.json
index e766e83..8cae479 100644
--- a/schema.neo4j.json
+++ b/schema.neo4j.json
@@ -15,8 +15,8 @@
         "language": "string",
         "max_level": "integer",
         "k_limit": "integer",
-        "name": "string",
-        "version": "string"
+        "analyzer_name": "string",
+        "analyzer_version": "string"
       }
     },
     {
diff --git a/src/build/neo4j/project.ts b/src/build/neo4j/project.ts
index 9a7908f..198b04e 100644
--- a/src/build/neo4j/project.ts
+++ b/src/build/neo4j/project.ts
@@ -52,9 +52,11 @@ export function project(app: V2Application, _appName?: string): GraphRows {
     max_level: app.max_level,
     k_limit: app.k_limit ?? null,
     // Same analyzer{name,version} the JSON envelope carries (emit.ts) — the two co-primary
-    // projections must never diverge on analyzer identity (issue #43).
-    name: app.analyzer.name,
-    version: app.analyzer.version,
+    // projections must never diverge on analyzer identity (issue #43). Namespaced as
+    // analyzer_name/analyzer_version (not bare name/version) to avoid colliding with the
+    // app-name param (project()'s _appName) and every other CanNode's bare `name`.
+    analyzer_name: app.analyzer.name,
+    analyzer_version: app.analyzer.version,
   }));
 
   for (const mod of Object.values(root.symbol_table)) {
diff --git a/src/build/neo4j/schema.ts b/src/build/neo4j/schema.ts
index 4319bc5..4584af4 100644
--- a/src/build/neo4j/schema.ts
+++ b/src/build/neo4j/schema.ts
@@ -58,8 +58,10 @@ export const NODE_LABELS: NodeLabel[] = [
     key: "id",
     properties: {
       id: "string", schema_version: "string", language: "string", max_level: "integer", k_limit: "integer",
-      // Analyzer identity — mirrors the JSON envelope's `analyzer{name,version}` (issue #43).
-      name: "string", version: "string",
+      // Analyzer identity — mirrors the JSON envelope's `analyzer{name,version}` (issue #43),
+      // namespaced (not bare name/version) to avoid colliding with the app-name param / every
+      // other CanNode's bare `name`.
+      analyzer_name: "string", analyzer_version: "string",
     },
   },
   {
diff --git a/test/neo4j-schema.test.ts b/test/neo4j-schema.test.ts
index 35aca27..0c0d813 100644
--- a/test/neo4j-schema.test.ts
+++ b/test/neo4j-schema.test.ts
@@ -101,8 +101,8 @@ describe(":Application node carries analyzer identity (issue #43)", () => {
   test("version matches package.json (the same source the JSON envelope's analyzer.version uses)", () => {
     const appNode = rows.nodes.find((n) => n.labels.includes("Application"));
     expect(appNode, "no :Application node projected").toBeDefined();
-    expect(appNode!.props.version).toBe(pkg.version);
-    expect(appNode!.props.name).toBe("codeanalyzer-typescript");
+    expect(appNode!.props.analyzer_version).toBe(pkg.version);
+    expect(appNode!.props.analyzer_name).toBe("codeanalyzer-typescript");
   });
 });
 

From 810c18f3d4438e4cd6c553aeec20061db17f78c9 Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Tue, 7 Jul 2026 07:24:29 -0400
Subject: [PATCH 17/32] chore: escape NUL key separators as \0 to restore text
 diffs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

src/build/neo4j/rows.ts and src/schema/v2/dataflow.ts used raw 0x00
bytes as template-literal key separators (Map keys / sort-comparator
keys), which made git treat both files as binary and hid contract-
adjacent edits from review. Replace each raw NUL with the `\0` escape
sequence — at runtime "\0" is still U+0000, so every key built from it
is byte-identical; only the on-disk representation changes, from
binary to plain text.
---
 src/build/neo4j/rows.ts   | Bin 5810 -> 5818 bytes
 src/schema/v2/dataflow.ts | Bin 13360 -> 13365 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)

diff --git a/src/build/neo4j/rows.ts b/src/build/neo4j/rows.ts
index f7900e946b464045d4b302e270ef4dc8f0403cad..d604701e79885614ffdbd3bef2fdd0e1327caf64 100644
GIT binary patch
delta 96
zcmdm_yGwUN2nSP)!RAm7IVKQY!qv$Nq$mI5*91`-0)dh-1}fEwdTB-Zxq4-ZIi;z!
c5P_2X$&3Qxla~t!3xfobP*rR`E%2Nb0HDqvGXMYp

delta 78
zcmdm`yGeIL2nQp><}eO9CLmSD)yc}pFqu(66G-X^1PU^!R43}C73JsZl_lnsrq(h{
So*-ZV5=}x8-F#W#IV%7<%oh>>

diff --git a/src/schema/v2/dataflow.ts b/src/schema/v2/dataflow.ts
index 784c548e60d47e7d35cd14042a5c0774074756bb..72121cdb3986371d50c9eda53916308cd9ba820f 100644
GIT binary patch
delta 50
ucmdmxu{C2uk1$V+fl76%UP^IEZH&R@X~KJ1nPLnkhe+C^O3am<ECm48JrTkH

delta 45
rcmdm*u_0qak1!X5N_DDUN^wao!{!;nds!J7CWlMfBa1GQoGb+ZYS9l1


From 114f0e18ea7b97e8db30e51d0710d0841acab25d Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Tue, 7 Jul 2026 07:34:01 -0400
Subject: [PATCH 18/32] test: cover interface-extends-interface EXTENDS and
 entry/exit span slices (#45)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds a first-party `ColoredShape extends Shape` interface to the dataflow-app
hierarchy fixture and asserts the resulting Interface→Interface EXTENDS edge
by node identity in the neo4j schema test — the one heritage path #33 handles
but nothing previously exercised.

Also asserts that L3 `@entry`/`@exit` body nodes byte-slice to the callable's
whole span (per extract.ts's emitNode), alongside the existing statement-node
slice test. Confirms `param` is contracted out before emission (folded onto
`@entry`/`@formal_in`) and is never present as a raw body node, so no slice
test is fabricated for it.
---
 test/fixtures/dataflow-app/src/hierarchy.ts |  7 +++-
 test/neo4j-schema.test.ts                   | 19 ++++++++++-
 test/schema-v2.test.ts                      | 37 +++++++++++++++++++++
 3 files changed, 61 insertions(+), 2 deletions(-)

diff --git a/test/fixtures/dataflow-app/src/hierarchy.ts b/test/fixtures/dataflow-app/src/hierarchy.ts
index 79da20e..4b6eb02 100644
--- a/test/fixtures/dataflow-app/src/hierarchy.ts
+++ b/test/fixtures/dataflow-app/src/hierarchy.ts
@@ -1,4 +1,5 @@
-/** A minimal first-party class hierarchy — exercises the Neo4j EXTENDS/IMPLEMENTS projection. */
+/** A minimal first-party class/interface hierarchy — exercises the Neo4j EXTENDS/IMPLEMENTS
+ * projection, including interface→interface EXTENDS (`ColoredShape extends Shape`). */
 
 export interface Shape {
   area(): number;
@@ -8,6 +9,10 @@ export interface Labeled {
   readonly label: string;
 }
 
+export interface ColoredShape extends Shape {
+  readonly color: string;
+}
+
 export class Rectangle implements Shape {
   constructor(
     protected readonly width: number,
diff --git a/test/neo4j-schema.test.ts b/test/neo4j-schema.test.ts
index 0c0d813..ccc6e83 100644
--- a/test/neo4j-schema.test.ts
+++ b/test/neo4j-schema.test.ts
@@ -108,7 +108,8 @@ describe(":Application node carries analyzer identity (issue #43)", () => {
 
 // ---- Class inheritance: EXTENDS/IMPLEMENTS (issue #33) ------------------------------------------
 // dataflow-app's src/hierarchy.ts is a minimal, first-party heritage fixture: `Rectangle implements
-// Shape`, `Square extends Rectangle implements Labeled`.
+// Shape`, `Square extends Rectangle implements Labeled`, `ColoredShape extends Shape` (interface→
+// interface heritage — issue #45).
 
 describe("neo4j inheritance edges (issue #33)", () => {
   test("EXTENDS and IMPLEMENTS are declared in the schema catalog", () => {
@@ -145,4 +146,20 @@ describe("neo4j inheritance edges (issue #33)", () => {
       expect(nodeValues.has(e.to.value), `dangling EXTENDS/IMPLEMENTS target ${e.to.value}`).toBe(true);
     }
   });
+
+  test("interface-extends-interface projects an EXTENDS edge with an Interface source AND target (issue #45)", () => {
+    const coloredShape = nodeBySignature("src/hierarchy.ColoredShape");
+    const shape = nodeBySignature("src/hierarchy.Shape");
+    expect(coloredShape, "ColoredShape node").toBeDefined();
+    expect(shape, "Shape node").toBeDefined();
+    expect(specificLabel(coloredShape!.labels)).toBe("Interface");
+    expect(specificLabel(shape!.labels)).toBe("Interface");
+
+    const ext = rows.edges.filter((e) => e.type === "EXTENDS");
+    expect(ext.some((e) => e.from.value === coloredShape!.value && e.to.value === shape!.value)).toBe(true);
+
+    const nodeValues = new Set(rows.nodes.map((n) => n.value));
+    expect(nodeValues.has(coloredShape!.value)).toBe(true);
+    expect(nodeValues.has(shape!.value)).toBe(true);
+  });
 });
diff --git a/test/schema-v2.test.ts b/test/schema-v2.test.ts
index 830f838..403e5c5 100644
--- a/test/schema-v2.test.ts
+++ b/test/schema-v2.test.ts
@@ -448,6 +448,43 @@ describe("schema v2 — L3 intraprocedural dataflow", () => {
     expect(e).toBeGreaterThan(s);
     expect(mod.source.slice(s, e)).toBe('let label = "none";');
   });
+
+  test("@entry/@exit body nodes are source-sliceable and carry the whole-callable span (issue #45)", () => {
+    // Per extract.ts's emitNode: "ENTRY/EXIT carry the whole callable's span" — unlike statement
+    // nodes (which slice out just their own text), entry/exit should reproduce the callable's
+    // entire declaration, including its `export` modifier.
+    const mod = dfL3.application.symbol_table["src/flow.ts"];
+    const classify = mod.functions.classify as V2Callable;
+    const entry = classify.body["@entry"];
+    const exit = classify.body["@exit"];
+    expect(entry?.kind).toBe("entry");
+    expect(exit?.kind).toBe("exit");
+
+    const [cs, ce] = (classify.span as { bytes: [number, number] }).bytes;
+    const callableText = mod.source.slice(cs, ce);
+    expect(callableText.startsWith("export function classify")).toBe(true);
+
+    for (const node of [entry, exit]) {
+      const [s, e] = (node as { span: { bytes: [number, number] } }).span.bytes;
+      expect(e).toBeGreaterThan(s);
+      const slice = mod.source.slice(s, e);
+      expect(slice.length).toBeGreaterThan(0);
+      expect(slice).toBe(callableText); // whole-callable span, byte-identical to classify's own span
+    }
+  });
+
+  // `param` is contracted out before emission (dataflow.ts: `if (n.kind === "param") continue;` in
+  // emitL3) — a param folds onto `@entry` at L3 and only reappears, synthetically, as
+  // `@formal_in:N` at L4 (asserted below). So there is no emitted `param`-kind body node to slice;
+  // slice fidelity for raw `param` is N/A at the emitted-tree level, not merely untested.
+  test("no raw `param`-kind body node is ever emitted (contracted onto @entry/@formal_in)", () => {
+    for (const c of allCallables(dfL3.application)) {
+      for (const node of Object.values(c.body)) expect(node.kind).not.toBe("param");
+    }
+    for (const c of allCallables(dfL4.application)) {
+      for (const node of Object.values(c.body)) expect(node.kind).not.toBe("param");
+    }
+  });
 });
 
 describe("schema v2 — L4 interprocedural SDG", () => {

From 9e9a0d46c99e37d4f155093e325a79081b8175e5 Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Tue, 7 Jul 2026 07:40:03 -0400
Subject: [PATCH 19/32] fix(test): update neo4j bolt test to schema v2 :CanNode
 label

The container-gated bolt test still queried the v1-era :Symbol label,
which no longer exists in schema v2 (every project-owned node carries
:CanNode plus a specific kind label). Since :CanNode spans ALL kinds
(not just the signature-keyed declaration types v1's :Symbol covered),
the exhaustiveness check now enumerates all 11 specific labels that
merge under :CanNode per schema.neo4j.json: Module, Class, Interface,
Enum, TypeAlias, Namespace, Callable, Field, BodyNode, External,
AnonymousCallable.
---
 test/neo4j-bolt.test.ts | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/test/neo4j-bolt.test.ts b/test/neo4j-bolt.test.ts
index c82e71b..47ca0bf 100644
--- a/test/neo4j-bolt.test.ts
+++ b/test/neo4j-bolt.test.ts
@@ -96,13 +96,14 @@ containerSuite("neo4j bolt writer", () => {
       expect(await num("MATCH (n) RETURN count(n)")).toBe(rows.nodes.length);
       expect(await num("MATCH ()-[r]->() RETURN count(r)")).toBe(rows.edges.length);
 
-      // Shared :Symbol label spans the signature-keyed declaration kinds.
-      const symbol = await num("MATCH (s:Symbol) RETURN count(s)");
+      // Shared :CanNode label spans every project-owned node kind (schema v2's universal
+      // merge label — Application is the only node kind that sits outside it).
+      const canNode = await num("MATCH (s:CanNode) RETURN count(s)");
       const kinds = await num(
-        "MATCH (s:Symbol) WHERE s:Callable OR s:Class OR s:Interface OR s:Enum OR s:TypeAlias OR s:Namespace OR s:External RETURN count(s)",
+        "MATCH (s:CanNode) WHERE s:Module OR s:Class OR s:Interface OR s:Enum OR s:TypeAlias OR s:Namespace OR s:Callable OR s:Field OR s:BodyNode OR s:External OR s:AnonymousCallable RETURN count(s)",
       );
-      expect(symbol).toBeGreaterThan(0);
-      expect(kinds).toBe(symbol);
+      expect(canNode).toBeGreaterThan(0);
+      expect(kinds).toBe(canNode);
 
       // Constraints + indexes were created up front.
       expect(await num("SHOW CONSTRAINTS YIELD name RETURN count(*)")).toBeGreaterThanOrEqual(8);

From 83fe4b3c0c3baa9c08ae4afa4bcea222184827fe Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Tue, 14 Jul 2026 21:23:32 -0400
Subject: [PATCH 20/32] chore: integrate 1.1.0 twin machinery with the v2
 catalog after rebase

---
 schema.neo4j.json          | 17 +++++++++++++++-
 src/build/neo4j/project.ts |  4 ++--
 src/build/neo4j/rows.ts    |  8 ++++++++
 src/build/neo4j/schema.ts  | 40 ++++++++++++++++++++++++++++++++++++++
 test/neo4j-schema.test.ts  | 25 ++++++++++++++++++++----
 test/neo4j-twins.test.ts   | 22 ++++++++++++++-------
 6 files changed, 102 insertions(+), 14 deletions(-)

diff --git a/schema.neo4j.json b/schema.neo4j.json
index 8cae479..3c8411b 100644
--- a/schema.neo4j.json
+++ b/schema.neo4j.json
@@ -406,5 +406,20 @@
   "indexes": [
     "CREATE INDEX callable_name IF NOT EXISTS FOR (c:Callable) ON (c.name)",
     "CREATE INDEX cannode_kind IF NOT EXISTS FOR (n:CanNode) ON (n.kind)"
-  ]
+  ],
+  "label_twins": {
+    "Application": "TSApplication",
+    "Module": "TSModule",
+    "Class": "TSClass",
+    "Interface": "TSInterface",
+    "Enum": "TSEnum",
+    "TypeAlias": "TSTypeAlias",
+    "Namespace": "TSNamespace",
+    "Callable": "TSCallable",
+    "Field": "TSField",
+    "BodyNode": "TSBodyNode",
+    "External": "TSExternal",
+    "AnonymousCallable": "TSAnonymousCallable",
+    "Entrypoint": "TSEntrypoint"
+  }
 }
diff --git a/src/build/neo4j/project.ts b/src/build/neo4j/project.ts
index 198b04e..fe46857 100644
--- a/src/build/neo4j/project.ts
+++ b/src/build/neo4j/project.ts
@@ -11,7 +11,7 @@
  */
 
 import type { V2Application, V2BodyNode, V2Callable, V2External, V2Field, V2Module, V2Node, V2Root, V2Type } from "../../schema/v2";
-import { SCHEMA_VERSION } from "./schema";
+import { SCHEMA_VERSION, withTwins } from "./schema";
 import { type GraphRows, type NodeRef, type Prop, type Props, RowBuilder, prune } from "./rows";
 
 /** The shared MERGE label + key every can://-id-keyed node is addressed by. */
@@ -42,7 +42,7 @@ const KIND_LABEL: Record<string, string> = {
 };
 
 export function project(app: V2Application, _appName?: string): GraphRows {
-  const b = new RowBuilder();
+  const b = new RowBuilder(withTwins);
   const root: V2Root = app.application;
 
   const appRef = b.node(["Application"], "id", root.id, prune({
diff --git a/src/build/neo4j/rows.ts b/src/build/neo4j/rows.ts
index d604701..02200d0 100644
--- a/src/build/neo4j/rows.ts
+++ b/src/build/neo4j/rows.ts
@@ -61,11 +61,19 @@ export class RowBuilder {
   private readonly deferred: EdgeRow[] = []; // edges gated against node existence at finish()
   private readonly keys = new Set<string>(); // every node value seen, for resolved-gating
 
+  /**
+   * @param expand optional label-set expander applied to every node's labels (the schema layer
+   * injects its twin-label policy here; rows.ts itself stays schema-agnostic). Must keep the
+   * merge label at index 0.
+   */
+  constructor(private readonly expand: (labels: string[]) => string[] = (l) => l) {}
+
   /**
    * Upsert a node. Re-seeing the same (mergeLabel, value) merges props (last write wins) and
    * unions labels — the in-memory analog of `MERGE (n:Label {key}) SET n += props`.
    */
   node(labels: string[], keyProp: string, value: string, props: Props): NodeRef {
+    labels = this.expand(labels);
     const id = `${labels[0]}\0${value}`;
     const existing = this.nodes.get(id);
     if (existing) {
diff --git a/src/build/neo4j/schema.ts b/src/build/neo4j/schema.ts
index 4584af4..3196eb5 100644
--- a/src/build/neo4j/schema.ts
+++ b/src/build/neo4j/schema.ts
@@ -38,6 +38,35 @@ export interface RelType {
 /** Labels layered onto a node in addition to its primary/specific label. */
 export const MARKER_LABELS = ["Entrypoint"] as const;
 
+/**
+ * Language-namespace twins (transient dual-labeling, issue #65): every specific and marker label is
+ * also stamped as `TS<Label>` so a shared multi-language database can attribute TS nodes (epic #64).
+ * The shared MERGE labels (`Symbol`, `CanNode`) deliberately have NO twin — MERGE targets, keys and
+ * constraints are unchanged. This dual-label state is transient; the vocabulary is finalized later.
+ */
+export const TS_PREFIX = "TS";
+
+/** The TS-prefixed twin of a specific or marker label. */
+export const twinOf = (label: string): string => `${TS_PREFIX}${label}`;
+
+/** Shared merge labels never get a twin — they carry the constraint; node identity is unchanged. */
+const UNTWINNED = new Set(["Symbol", "CanNode"]);
+
+/**
+ * Expand a projection label set with its twins: order preserved, shared merge labels skipped,
+ * idempotent. Any label already starting with `TS` is treated as a twin and never re-prefixed — so
+ * no bare label may legitimately begin with `TS`.
+ */
+export function withTwins(labels: string[]): string[] {
+  const out = [...labels];
+  for (const l of labels) {
+    if (UNTWINNED.has(l) || l.startsWith(TS_PREFIX)) continue;
+    const t = twinOf(l);
+    if (!out.includes(t)) out.push(t);
+  }
+  return out;
+}
+
 /** The shared MERGE label for every can://-id-keyed node (one constraint; uniform edge endpoints). */
 const CAN = "CanNode";
 const SPAN = { start_line: "integer", end_line: "integer" } as const;
@@ -200,6 +229,16 @@ export interface SchemaDocument {
   relationship_types: RelType[];
   constraints: readonly string[];
   indexes: readonly string[];
+  /** Specific/marker label → its TS-prefixed twin (both are present on every emitted node). */
+  label_twins: Record<string, string>;
+}
+
+/** One twin per specific label + per marker label — derived from the catalogs, never drifts. */
+function labelTwins(): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const n of NODE_LABELS) out[n.label] = twinOf(n.label);
+  for (const m of MARKER_LABELS) out[m] = twinOf(m);
+  return out;
 }
 
 /** Build the full machine-readable schema document emitted by `--emit schema`. */
@@ -212,5 +251,6 @@ export function buildSchemaDocument(): SchemaDocument {
     relationship_types: REL_TYPES,
     constraints: CONSTRAINTS,
     indexes: INDEXES,
+    label_twins: labelTwins(),
   };
 }
diff --git a/test/neo4j-schema.test.ts b/test/neo4j-schema.test.ts
index ccc6e83..8ef5a7e 100644
--- a/test/neo4j-schema.test.ts
+++ b/test/neo4j-schema.test.ts
@@ -16,6 +16,8 @@ import {
   REL_TYPES,
   buildSchemaDocument,
   project,
+  twinOf,
+  withTwins,
 } from "../src/build/neo4j";
 import { analyze } from "../src/core";
 import type { AnalysisOptions } from "../src/options";
@@ -44,13 +46,17 @@ const byLabel = new Map(NODE_LABELS.map((n) => [n.label, n]));
 const mergeOf = new Map(NODE_LABELS.map((n) => [n.label, n.mergeLabel]));
 const relByType = new Map(REL_TYPES.map((r) => [r.type, r]));
 const markers = new Set<string>(MARKER_LABELS);
+const twins = new Set<string>([
+  ...NODE_LABELS.map((n) => twinOf(n.label)),
+  ...MARKER_LABELS.map((m) => twinOf(m)),
+]);
 const mergeLabelsFor = (specifics: string[]) => new Set(specifics.map((s) => mergeOf.get(s)));
 
-/** The specific (schema) label for a node row: the non-merge, non-marker label (`Application`
- * has only its own label; every `CanNode` carries exactly one specific kind label). */
+/** The specific (schema) label for a node row: the non-merge, non-marker, non-twin label
+ * (`Application` has only its own label; every `CanNode` carries exactly one specific kind label). */
 function specificLabel(labels: string[]): string {
   const merge = labels[0];
-  return labels.find((l) => l !== merge && !markers.has(l)) ?? merge;
+  return labels.find((l) => l !== merge && !markers.has(l) && !twins.has(l)) ?? merge;
 }
 
 const rows = await fixtureRows();
@@ -65,7 +71,7 @@ describe("neo4j schema conformance", () => {
       expect(node.labels[0]).toBe(decl!.mergeLabel);
 
       for (const label of node.labels) {
-        const ok = label === decl!.mergeLabel || label === specific || markers.has(label);
+        const ok = label === decl!.mergeLabel || label === specific || markers.has(label) || twins.has(label);
         expect(ok, `unexpected label '${label}' on ${specific}`).toBe(true);
       }
       for (const key of Object.keys(node.props)) {
@@ -91,6 +97,17 @@ describe("neo4j schema conformance", () => {
     const fresh = JSON.stringify(buildSchemaDocument(), null, 2).trim();
     expect(onDisk).toBe(fresh);
   });
+
+  test("every node carries exactly the TS twins of its base labels (transient dual-labeling)", () => {
+    for (const node of rows.nodes) {
+      const base = node.labels.filter((l) => !twins.has(l));
+      expect(new Set(node.labels), `bad twin set on ${node.labels.join(":")} ${node.value}`).toEqual(
+        new Set(withTwins(base)),
+      );
+      // the shared merge label (`CanNode` / `Application`) stays bare at index 0.
+      expect(twins.has(node.labels[0]), `merge label must stay bare: ${node.labels[0]}`).toBe(false);
+    }
+  });
 });
 
 // ---- :Application analyzer identity (issue #43) ------------------------------------------------
diff --git a/test/neo4j-twins.test.ts b/test/neo4j-twins.test.ts
index 62db1a5..c2e0bea 100644
--- a/test/neo4j-twins.test.ts
+++ b/test/neo4j-twins.test.ts
@@ -1,6 +1,8 @@
 /**
- * Twin-label vocabulary (graph schema 1.1.0, issue #65): every specific and marker label has a
- * TS-prefixed twin; the shared merge label `Symbol` deliberately has none (epic #64).
+ * Twin-label vocabulary (transient dual-labeling on graph schema 2.0.0, issue #65): every specific
+ * and marker label has a TS-prefixed twin; the shared merge labels (`Symbol`, `CanNode`)
+ * deliberately have none (epic #64). The v2 catalog merges on `CanNode`, so it is the merge label
+ * that must stay bare here.
  */
 import { describe, expect, test } from "bun:test";
 import {
@@ -20,25 +22,31 @@ describe("TS twin-label vocabulary", () => {
     expect(twinOf("Entrypoint")).toBe("TSEntrypoint");
   });
 
-  test("withTwins appends a twin per label, keeps order, and skips Symbol", () => {
+  test("withTwins appends a twin per label, keeps order, and skips shared merge labels", () => {
     expect(withTwins(["Module"])).toEqual(["Module", "TSModule"]);
+    // both shared merge labels are skipped (v2 merges on CanNode)
+    expect(withTwins(["CanNode", "Callable"])).toEqual(["CanNode", "Callable", "TSCallable"]);
     expect(withTwins(["Symbol", "Class"])).toEqual(["Symbol", "Class", "TSClass"]);
-    expect(withTwins(["Symbol", "Callable", "Entrypoint"])).toEqual([
-      "Symbol", "Callable", "Entrypoint", "TSCallable", "TSEntrypoint",
+    expect(withTwins(["CanNode", "Callable", "Entrypoint"])).toEqual([
+      "CanNode", "Callable", "Entrypoint", "TSCallable", "TSEntrypoint",
     ]);
     // idempotent: an already-expanded set gains nothing
     expect(withTwins(["Module", "TSModule"])).toEqual(["Module", "TSModule"]);
   });
 
-  test("schema version is 1.1.0 (additive MINOR)", () => {
-    expect(SCHEMA_VERSION).toBe("1.1.0");
+  test("schema version is 2.0.0 (v2 catalog)", () => {
+    expect(SCHEMA_VERSION).toBe("2.0.0");
   });
 
   test("schema document maps every specific + marker label to its twin", () => {
     const doc = buildSchemaDocument();
     for (const n of NODE_LABELS) expect(doc.label_twins[n.label]).toBe(twinOf(n.label));
     for (const m of MARKER_LABELS) expect(doc.label_twins[m]).toBe(twinOf(m));
+    // shared merge labels are never specific/marker labels, so they map to nothing
+    expect(doc.label_twins["CanNode"]).toBeUndefined();
     expect(doc.label_twins["Symbol"]).toBeUndefined();
+    // 12 node labels + 1 marker (Entrypoint) = 13 twins
+    expect(Object.keys(doc.label_twins).length).toBe(13);
     expect(Object.keys(doc.label_twins).length).toBe(NODE_LABELS.length + MARKER_LABELS.length);
   });
 });

From 70aeb51bc675b534b454192c248ba1272d40192c Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Tue, 14 Jul 2026 21:35:52 -0400
Subject: [PATCH 21/32] fix(schema)!: de-advertise never-populated entrypoints
 and accessed_symbols (closes #55, closes #60)

---
 schema.neo4j.json                  | 21 ++++-----------------
 src/build/neo4j/project.ts         | 25 ++++---------------------
 src/build/neo4j/schema.ts          | 13 +++----------
 src/schema/schema.ts               | 16 ----------------
 src/syntactic_analysis/builders.ts |  5 -----
 test/neo4j-schema.test.ts          |  9 +++++++++
 test/neo4j-twins.test.ts           |  8 ++------
 7 files changed, 22 insertions(+), 75 deletions(-)

diff --git a/schema.neo4j.json b/schema.neo4j.json
index 3c8411b..d409952 100644
--- a/schema.neo4j.json
+++ b/schema.neo4j.json
@@ -1,9 +1,7 @@
 {
   "schema_version": "2.0.0",
   "generator": "codeanalyzer-typescript",
-  "marker_labels": [
-    "Entrypoint"
-  ],
+  "marker_labels": [],
   "node_labels": [
     {
       "label": "Application",
@@ -51,12 +49,7 @@
         "is_exported": "boolean",
         "is_ambient": "boolean",
         "start_line": "integer",
-        "end_line": "integer",
-        "framework": "string",
-        "detection_source": "string",
-        "route_path": "string",
-        "http_methods": "string[]",
-        "entrypoint_count": "integer"
+        "end_line": "integer"
       }
     },
     {
@@ -148,12 +141,7 @@
         "is_ambient": "boolean",
         "is_implicit": "boolean",
         "start_line": "integer",
-        "end_line": "integer",
-        "framework": "string",
-        "detection_source": "string",
-        "route_path": "string",
-        "http_methods": "string[]",
-        "entrypoint_count": "integer"
+        "end_line": "integer"
       }
     },
     {
@@ -419,7 +407,6 @@
     "Field": "TSField",
     "BodyNode": "TSBodyNode",
     "External": "TSExternal",
-    "AnonymousCallable": "TSAnonymousCallable",
-    "Entrypoint": "TSEntrypoint"
+    "AnonymousCallable": "TSAnonymousCallable"
   }
 }
diff --git a/src/build/neo4j/project.ts b/src/build/neo4j/project.ts
index fe46857..0d66ab2 100644
--- a/src/build/neo4j/project.ts
+++ b/src/build/neo4j/project.ts
@@ -12,7 +12,7 @@
 
 import type { V2Application, V2BodyNode, V2Callable, V2External, V2Field, V2Module, V2Node, V2Root, V2Type } from "../../schema/v2";
 import { SCHEMA_VERSION, withTwins } from "./schema";
-import { type GraphRows, type NodeRef, type Prop, type Props, RowBuilder, prune } from "./rows";
+import { type GraphRows, type NodeRef, type Props, RowBuilder, prune } from "./rows";
 
 /** The shared MERGE label + key every can://-id-keyed node is addressed by. */
 const CAN = "CanNode";
@@ -115,8 +115,7 @@ function projectType(b: RowBuilder, t: V2Type, parent: NodeRef, fileKey: string)
 }
 
 function projectCallable(b: RowBuilder, c: V2Callable, owner: NodeRef, ownerRel: string, fileKey: string): void {
-  const labels = hasEntrypoints(c) ? [CAN, "Callable", "Entrypoint"] : [CAN, "Callable"];
-  const node = b.node(labels, "id", c.id, callableProps(c, fileKey));
+  const node = b.node([CAN, "Callable"], "id", c.id, callableProps(c, fileKey));
   b.edge(ownerRel, owner, node);
 
   // Body nodes (L1: call sites; L3+: statements + synthetic vertices) + their overlays.
@@ -162,7 +161,7 @@ function typeProps(t: V2Type, fileKey: string): Props {
     aliased_type: str((t as V2Node).aliased_type),
     is_abstract: bool((t as V2Node).is_abstract), is_const: bool((t as V2Node).is_const),
     is_exported: bool((t as V2Node).is_exported), is_ambient: bool((t as V2Node).is_ambient),
-    ...span(t), ...entrypointProps(t),
+    ...span(t),
   });
 }
 
@@ -174,7 +173,7 @@ function callableProps(c: V2Callable, fileKey: string): Props {
     is_static: bool((c as V2Node).is_static), is_abstract: bool((c as V2Node).is_abstract),
     is_async: bool((c as V2Node).is_async), is_generator: bool((c as V2Node).is_generator),
     is_exported: bool((c as V2Node).is_exported), is_ambient: bool((c as V2Node).is_ambient),
-    is_implicit: bool((c as V2Node).is_implicit), ...span(c), ...entrypointProps(c), _module: fileKey,
+    is_implicit: bool((c as V2Node).is_implicit), ...span(c), _module: fileKey,
   });
 }
 
@@ -220,22 +219,6 @@ function spanCol(n: V2Node, which: "start" | "end"): number | undefined {
   return s?.[which]?.[1];
 }
 
-function hasEntrypoints(n: V2Node): boolean {
-  const eps = (n as Record<string, unknown>).entrypoints;
-  return Array.isArray(eps) && eps.length > 0;
-}
-
-function entrypointProps(n: V2Node): Record<string, Prop> {
-  const eps = (n as { entrypoints?: Array<{ framework?: string; detection_source?: string; route_path?: string; http_methods?: string[] }> }).entrypoints;
-  if (!Array.isArray(eps) || !eps.length) return {};
-  const first = eps[0] ?? {};
-  const http = [...new Set(eps.flatMap((e) => (Array.isArray(e.http_methods) ? e.http_methods : [])))];
-  return prune({
-    framework: str(first.framework), detection_source: str(first.detection_source),
-    route_path: str(first.route_path), http_methods: http.length ? http : null, entrypoint_count: eps.length,
-  });
-}
-
 // value coercion (v2 attrs are `unknown`; Neo4j props must be scalars / homogeneous arrays)
 const str = (v: unknown): string | null => (typeof v === "string" ? v : null);
 const num = (v: unknown): number | null => (typeof v === "number" ? v : null);
diff --git a/src/build/neo4j/schema.ts b/src/build/neo4j/schema.ts
index 3196eb5..0770649 100644
--- a/src/build/neo4j/schema.ts
+++ b/src/build/neo4j/schema.ts
@@ -36,7 +36,7 @@ export interface RelType {
 }
 
 /** Labels layered onto a node in addition to its primary/specific label. */
-export const MARKER_LABELS = ["Entrypoint"] as const;
+export const MARKER_LABELS = [] as const;
 
 /**
  * Language-namespace twins (transient dual-labeling, issue #65): every specific and marker label is
@@ -70,13 +70,6 @@ export function withTwins(labels: string[]): string[] {
 /** The shared MERGE label for every can://-id-keyed node (one constraint; uniform edge endpoints). */
 const CAN = "CanNode";
 const SPAN = { start_line: "integer", end_line: "integer" } as const;
-const ENTRYPOINT = {
-  framework: "string",
-  detection_source: "string",
-  route_path: "string",
-  http_methods: "string[]",
-  entrypoint_count: "integer",
-} as const;
 /** Every can://-keyed node carries these. */
 const COMMON = { id: "string", kind: "string", _module: "string" } as const;
 
@@ -105,7 +98,7 @@ export const NODE_LABELS: NodeLabel[] = [
     key: "id",
     properties: {
       ...COMMON, signature: "string", name: "string", base_classes: "string[]", implements_types: "string[]",
-      is_abstract: "boolean", is_exported: "boolean", is_ambient: "boolean", ...SPAN, ...ENTRYPOINT,
+      is_abstract: "boolean", is_exported: "boolean", is_ambient: "boolean", ...SPAN,
     },
   },
   {
@@ -140,7 +133,7 @@ export const NODE_LABELS: NodeLabel[] = [
       ...COMMON, signature: "string", name: "string", return_type: "string", cyclomatic_complexity: "integer",
       accessibility: "string", accessor_kind: "string", is_static: "boolean", is_abstract: "boolean",
       is_async: "boolean", is_generator: "boolean", is_exported: "boolean", is_ambient: "boolean", is_implicit: "boolean",
-      ...SPAN, ...ENTRYPOINT,
+      ...SPAN,
     },
   },
   { label: "Field", mergeLabel: CAN, key: "id", properties: { ...COMMON, name: "string", type: "string", ...SPAN } },
diff --git a/src/schema/schema.ts b/src/schema/schema.ts
index 31eb646..64959b2 100644
--- a/src/schema/schema.ts
+++ b/src/schema/schema.ts
@@ -174,13 +174,11 @@ export interface TSCallable {
   start_line: number;
   end_line: number;
   code_start_line: number;
-  accessed_symbols: TSSymbol[];
   call_sites: TSCallsite[];
   inner_callables: Record<string, TSCallable>;
   inner_classes: Record<string, TSClass>;
   local_variables: TSVariableDeclaration[];
   cyclomatic_complexity: number;
-  entrypoints: TSEntrypoint[]; // non-empty ⇒ this callable is an entrypoint (level-2 finders populate)
   // --- TypeScript-native typed fields ---
   kind: TSCallableKind;
   accessibility: string | null; // public | private | protected | null
@@ -234,7 +232,6 @@ export interface TSClass {
   methods: Record<string, TSCallable>;
   attributes: Record<string, TSClassAttribute>;
   inner_classes: Record<string, TSClass>;
-  entrypoints: TSEntrypoint[]; // class-level entrypoint (e.g. a framework @Controller); empty otherwise
   is_abstract: boolean;
   is_exported: boolean;
   is_ambient: boolean;
@@ -373,19 +370,6 @@ export interface TSCallEdge {
   tags: Record<string, string>;
 }
 
-// ----------------------------------------------------------------------------------------------
-// Entrypoint (optional; level-2 / framework finders populate it — empty for level 1).
-// Embedded on the owning TSCallable/TSClass, so it carries no signature/source_file of its own.
-// ----------------------------------------------------------------------------------------------
-
-export interface TSEntrypoint {
-  framework: string;
-  detection_source: string; // decorator | base_class | convention | extension | ...
-  route_path: string | null;
-  http_methods: string[];
-  tags: Record<string, string>;
-}
-
 // ----------------------------------------------------------------------------------------------
 // Application (root)
 // ----------------------------------------------------------------------------------------------
diff --git a/src/syntactic_analysis/builders.ts b/src/syntactic_analysis/builders.ts
index 36f38ca..22952da 100644
--- a/src/syntactic_analysis/builders.ts
+++ b/src/syntactic_analysis/builders.ts
@@ -463,13 +463,11 @@ export function buildCallable(
     return_type: kind === "constructor" || kind === "setter" ? null : returnTypeText(fnNode),
     code: clamp(sigNode.getText(), 20000),
     ...declLines(sigNode),
-    accessed_symbols: [],
     call_sites,
     inner_callables,
     inner_classes,
     local_variables,
     cyclomatic_complexity: body ? computeCC(body) : 0,
-    entrypoints: [],
     kind,
     accessibility: accessibilityOf(fnNode),
     is_static: boolOf(fnNode, "isStatic"),
@@ -505,13 +503,11 @@ function implicitConstructor(classSig: string, filePath: string): { sig: string;
       start_line: -1,
       end_line: -1,
       code_start_line: -1,
-      accessed_symbols: [],
       call_sites: [],
       inner_callables: {},
       inner_classes: {},
       local_variables: [],
       cyclomatic_complexity: 0,
-      entrypoints: [],
       kind: "constructor",
       accessibility: null,
       is_static: false,
@@ -655,7 +651,6 @@ export function buildClass(cls: Node, root: string): { sig: string; cls: TSClass
       methods,
       attributes,
       inner_classes: {},
-      entrypoints: [],
       is_abstract: boolOf(cls, "isAbstract"),
       is_exported: isExportedDecl(cls),
       is_ambient: isAmbientDecl(cls),
diff --git a/test/neo4j-schema.test.ts b/test/neo4j-schema.test.ts
index 8ef5a7e..9c8079b 100644
--- a/test/neo4j-schema.test.ts
+++ b/test/neo4j-schema.test.ts
@@ -98,6 +98,15 @@ describe("neo4j schema conformance", () => {
     expect(onDisk).toBe(fresh);
   });
 
+  test("2.0.0 does not advertise never-populated surfaces (issues #55/#60)", () => {
+    const doc = buildSchemaDocument();
+    expect(doc.marker_labels.length).toBe(0);
+    const allProps = doc.node_labels.flatMap((n) => Object.keys(n.properties));
+    for (const dead of ["framework", "detection_source", "route_path", "http_methods", "entrypoint_count", "accessed_symbols_json"]) {
+      expect(allProps, `dead property still advertised: ${dead}`).not.toContain(dead);
+    }
+  });
+
   test("every node carries exactly the TS twins of its base labels (transient dual-labeling)", () => {
     for (const node of rows.nodes) {
       const base = node.labels.filter((l) => !twins.has(l));
diff --git a/test/neo4j-twins.test.ts b/test/neo4j-twins.test.ts
index c2e0bea..0b59a5e 100644
--- a/test/neo4j-twins.test.ts
+++ b/test/neo4j-twins.test.ts
@@ -19,7 +19,6 @@ describe("TS twin-label vocabulary", () => {
   test("twinOf prefixes with TS", () => {
     expect(TS_PREFIX).toBe("TS");
     expect(twinOf("Callable")).toBe("TSCallable");
-    expect(twinOf("Entrypoint")).toBe("TSEntrypoint");
   });
 
   test("withTwins appends a twin per label, keeps order, and skips shared merge labels", () => {
@@ -27,9 +26,6 @@ describe("TS twin-label vocabulary", () => {
     // both shared merge labels are skipped (v2 merges on CanNode)
     expect(withTwins(["CanNode", "Callable"])).toEqual(["CanNode", "Callable", "TSCallable"]);
     expect(withTwins(["Symbol", "Class"])).toEqual(["Symbol", "Class", "TSClass"]);
-    expect(withTwins(["CanNode", "Callable", "Entrypoint"])).toEqual([
-      "CanNode", "Callable", "Entrypoint", "TSCallable", "TSEntrypoint",
-    ]);
     // idempotent: an already-expanded set gains nothing
     expect(withTwins(["Module", "TSModule"])).toEqual(["Module", "TSModule"]);
   });
@@ -45,8 +41,8 @@ describe("TS twin-label vocabulary", () => {
     // shared merge labels are never specific/marker labels, so they map to nothing
     expect(doc.label_twins["CanNode"]).toBeUndefined();
     expect(doc.label_twins["Symbol"]).toBeUndefined();
-    // 12 node labels + 1 marker (Entrypoint) = 13 twins
-    expect(Object.keys(doc.label_twins).length).toBe(13);
+    // 12 node labels + 0 markers (none currently) = 12 twins
+    expect(Object.keys(doc.label_twins).length).toBe(12);
     expect(Object.keys(doc.label_twins).length).toBe(NODE_LABELS.length + MARKER_LABELS.length);
   });
 });

From 4c3b0914a08424b04594cc31875282b215fa6f6f Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Tue, 14 Jul 2026 21:38:54 -0400
Subject: [PATCH 22/32] fix(neo4j): relationship-identity discriminant for
 DDG/CFG_NEXT (issue #70)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A plain endpoint-pair MERGE collapses legitimately-distinct edges of one
type between the same two nodes: the DDG carries one edge per variable
(plus the prov split), and a conditional's true/false CFG_NEXT pair shares
its endpoints — the live graph silently materialized fewer dependence
edges than the projection produced, with var/prov/kind props last-write-wins.
Found in codeanalyzer-python during its v2 stage-5 gates (bolt count test
106 != 109) and fixed there the same way.

- EdgeRow gains an optional `key` discriminant; RowBuilder.edge passes it.
- bolt/cypher writers MERGE keyed families on `(a)-[r:TYPE {_k: row.k}]->(b)`
  and group keyed vs unkeyed rows separately.
- project(): DDG keyed per `(var, prov)`, CFG_NEXT per `kind`; CDG/SUMMARY/
  PARAM_* stay plain (their endpoint pairs are unique by construction).
- schema catalog declares `_k` on DDG/CFG_NEXT; schema.neo4j.json regenerated.
- test/neo4j-edge-identity.test.ts covers survival of per-var DDG rows, the
  keyed MERGE shape, and that undiscriminated families keep the plain MERGE.
---
 schema.neo4j.json                |  6 +++--
 src/build/neo4j/bolt.ts          |  9 ++++---
 src/build/neo4j/cypher.ts        |  8 +++---
 src/build/neo4j/project.ts       | 10 +++++--
 src/build/neo4j/rows.ts          | 14 +++++++---
 src/build/neo4j/schema.ts        |  8 ++++--
 test/neo4j-edge-identity.test.ts | 45 ++++++++++++++++++++++++++++++++
 7 files changed, 85 insertions(+), 15 deletions(-)
 create mode 100644 test/neo4j-edge-identity.test.ts

diff --git a/schema.neo4j.json b/schema.neo4j.json
index d409952..68dfa07 100644
--- a/schema.neo4j.json
+++ b/schema.neo4j.json
@@ -301,7 +301,8 @@
         "BodyNode"
       ],
       "properties": {
-        "kind": "string"
+        "kind": "string",
+        "_k": "string"
       }
     },
     {
@@ -324,7 +325,8 @@
       ],
       "properties": {
         "var": "string",
-        "prov": "string[]"
+        "prov": "string[]",
+        "_k": "string"
       }
     },
     {
diff --git a/src/build/neo4j/bolt.ts b/src/build/neo4j/bolt.ts
index c60102a..de1ee9a 100644
--- a/src/build/neo4j/bolt.ts
+++ b/src/build/neo4j/bolt.ts
@@ -150,18 +150,21 @@ async function upsertNodes(session: () => any, neo4j: any, nodes: NodeRow[]): Pr
 async function upsertEdges(session: () => any, neo4j: any, edges: EdgeRow[]): Promise<void> {
   const groups = new Map<string, EdgeRow[]>();
   for (const e of edges) {
-    bucket(groups, `${e.type}|${e.from.label}.${e.from.keyProp}|${e.to.label}.${e.to.keyProp}`).push(e);
+    bucket(groups, `${e.type}|${e.from.label}.${e.from.keyProp}|${e.to.label}.${e.to.keyProp}|${e.key !== undefined}`).push(e);
   }
 
   for (const group of groups.values()) {
     const { type, from, to } = group[0];
+    // Discriminated relationships MERGE on `{_k}` so several distinct edges of one type coexist
+    // between the same endpoint pair (per-var DDG, the true/false CFG_NEXT pair). See EdgeRow.key.
+    const relKey = group[0].key !== undefined ? " {_k: row.k}" : "";
     const cypher =
       `UNWIND $rows AS row ` +
       `MATCH (a:${from.label} {${from.keyProp}: row.f}) ` +
       `MATCH (b:${to.label} {${to.keyProp}: row.t}) ` +
-      `MERGE (a)-[r:${type}]->(b) SET r += row.p`;
+      `MERGE (a)-[r:${type}${relKey}]->(b) SET r += row.p`;
     for (const batch of chunk(group, BATCH)) {
-      const payload = batch.map((e) => ({ f: e.from.value, t: e.to.value, p: toParams(e.props, neo4j) }));
+      const payload = batch.map((e) => ({ f: e.from.value, t: e.to.value, k: e.key ?? null, p: toParams(e.props, neo4j) }));
       await withSession(session, (s) => s.run(cypher, { rows: payload }));
     }
   }
diff --git a/src/build/neo4j/cypher.ts b/src/build/neo4j/cypher.ts
index a724125..d66e5df 100644
--- a/src/build/neo4j/cypher.ts
+++ b/src/build/neo4j/cypher.ts
@@ -81,22 +81,24 @@ function nodeStatements(nodes: NodeRow[]): string[] {
 function edgeStatements(edges: EdgeRow[]): string[] {
   const groups = new Map<string, EdgeRow[]>();
   for (const e of edges) {
-    const k = `${e.type}|${e.from.label}.${e.from.keyProp}|${e.to.label}.${e.to.keyProp}`;
+    const k = `${e.type}|${e.from.label}.${e.from.keyProp}|${e.to.label}.${e.to.keyProp}|${e.key !== undefined}`;
     (groups.get(k) ?? groups.set(k, []).get(k)!).push(e);
   }
 
   const blocks: string[] = [];
   for (const group of groups.values()) {
     const { type, from, to } = group[0];
+    // Discriminated relationships MERGE on `{_k}` — see EdgeRow.key (issue #70).
+    const keyed = group[0].key !== undefined;
     for (const batch of chunk(group, BATCH)) {
       const list = batch
-        .map((e) => `  {f: ${cypherValue(e.from.value)}, t: ${cypherValue(e.to.value)}, p: ${cypherMap(e.props)}}`)
+        .map((e) => `  {f: ${cypherValue(e.from.value)}, t: ${cypherValue(e.to.value)}, ${keyed ? `k: ${cypherValue(e.key!)}, ` : ""}p: ${cypherMap(e.props)}}`)
         .join(",\n");
       blocks.push(
         `UNWIND [\n${list}\n] AS row\n` +
           `MATCH (a:${from.label} {${from.keyProp}: row.f})\n` +
           `MATCH (b:${to.label} {${to.keyProp}: row.t})\n` +
-          `MERGE (a)-[r:${type}]->(b)\n` +
+          `MERGE (a)-[r:${type}${keyed ? " {_k: row.k}" : ""}]->(b)\n` +
           `SET r += row.p;`,
       );
     }
diff --git a/src/build/neo4j/project.ts b/src/build/neo4j/project.ts
index 0d66ab2..3ebe77a 100644
--- a/src/build/neo4j/project.ts
+++ b/src/build/neo4j/project.ts
@@ -125,9 +125,15 @@ function projectCallable(b: RowBuilder, c: V2Callable, owner: NodeRef, ownerRel:
     b.edge("HAS_BODY_NODE", node, bref);
     if (typeof bn.callee === "string") b.edge("RESOLVES_TO", bref, ref(bn.callee));
   }
-  for (const e of edges(c.cfg)) b.edge("CFG_NEXT", ref(fq(c.id, e.src)), ref(fq(c.id, e.dst)), prune({ kind: e.kind ?? null }));
+  // kind-discriminated: a conditional's true/false pair between one endpoint pair must stay
+  // two relationships, not one MERGE (issue #70).
+  for (const e of edges(c.cfg)) b.edge("CFG_NEXT", ref(fq(c.id, e.src)), ref(fq(c.id, e.dst)), prune({ kind: e.kind ?? null }), e.kind ?? "");
   for (const e of edges(c.cdg)) b.edge("CDG", ref(fq(c.id, e.src)), ref(fq(c.id, e.dst)));
-  for (const e of edges(c.ddg)) b.edge("DDG", ref(fq(c.id, e.src)), ref(fq(c.id, e.dst)), prune({ var: e.var ?? null, prov: e.prov ?? null }));
+  // (var, prov)-discriminated: the DDG legitimately carries several edges between one statement
+  // pair (one per variable, and the prov split) — a plain endpoint-pair MERGE collapses them and
+  // silently drops dependences (issue #70).
+  for (const e of edges(c.ddg))
+    b.edge("DDG", ref(fq(c.id, e.src)), ref(fq(c.id, e.dst)), prune({ var: e.var ?? null, prov: e.prov ?? null }), `${e.var ?? ""}|${(e.prov ?? []).join(",")}`);
   for (const e of edges(c.summary)) b.edge("SUMMARY", ref(fq(c.id, e.src)), ref(fq(c.id, e.dst)), prune({ var: e.var ?? null }));
 
   // Nested callables (closures) + local classes.
diff --git a/src/build/neo4j/rows.ts b/src/build/neo4j/rows.ts
index 02200d0..fe4c5e2 100644
--- a/src/build/neo4j/rows.ts
+++ b/src/build/neo4j/rows.ts
@@ -33,6 +33,13 @@ export interface EdgeRow {
   from: NodeRef;
   to: NodeRef;
   props: Props;
+  /**
+   * Optional relationship discriminant: when set, the MERGE is on `{_k: key}` so several
+   * legitimately-distinct edges of one type may coexist between the same endpoint pair (per-var
+   * DDG edges, a conditional's true/false CFG_NEXT pair). Undefined keeps the plain
+   * endpoint-pair MERGE. (issue #70)
+   */
+  key?: string;
 }
 
 export interface GraphRows {
@@ -86,9 +93,10 @@ export class RowBuilder {
     return { label: labels[0], keyProp, value };
   }
 
-  /** An edge whose endpoints are known to exist (both ends emitted as nodes this run). */
-  edge(type: string, from: NodeRef, to: NodeRef, props: Props = {}): void {
-    this.edges.push({ type, from, to, props });
+  /** An edge whose endpoints are known to exist (both ends emitted as nodes this run).
+   * `key` sets the relationship discriminant (see EdgeRow.key). */
+  edge(type: string, from: NodeRef, to: NodeRef, props: Props = {}, key?: string): void {
+    this.edges.push({ type, from, to, props, key });
   }
 
   /**
diff --git a/src/build/neo4j/schema.ts b/src/build/neo4j/schema.ts
index 0770649..d57c8ae 100644
--- a/src/build/neo4j/schema.ts
+++ b/src/build/neo4j/schema.ts
@@ -172,9 +172,13 @@ export const REL_TYPES: RelType[] = [
     to: ["Callable", "External", "AnonymousCallable"],
     properties: { weight: "integer", prov: "string[]" },
   },
-  { type: "CFG_NEXT", from: ["BodyNode"], to: ["BodyNode"], properties: { kind: "string" } },
+  // `_k` is the relationship-identity discriminant (internal): CFG_NEXT merges per `kind`
+  // (a conditional's true/false pair), DDG per `(var, prov)` (one dependence per variable, plus
+  // the prov split) — a plain endpoint-pair MERGE would collapse legitimately-distinct edges
+  // (issue #70).
+  { type: "CFG_NEXT", from: ["BodyNode"], to: ["BodyNode"], properties: { kind: "string", _k: "string" } },
   { type: "CDG", from: ["BodyNode"], to: ["BodyNode"], properties: {} },
-  { type: "DDG", from: ["BodyNode"], to: ["BodyNode"], properties: { var: "string", prov: "string[]" } },
+  { type: "DDG", from: ["BodyNode"], to: ["BodyNode"], properties: { var: "string", prov: "string[]", _k: "string" } },
   { type: "SUMMARY", from: ["BodyNode"], to: ["BodyNode"], properties: { var: "string" } },
   { type: "PARAM_IN", from: ["BodyNode"], to: ["BodyNode"], properties: { var: "string" } },
   { type: "PARAM_OUT", from: ["BodyNode"], to: ["BodyNode"], properties: { var: "string" } },
diff --git a/test/neo4j-edge-identity.test.ts b/test/neo4j-edge-identity.test.ts
new file mode 100644
index 0000000..6525081
--- /dev/null
+++ b/test/neo4j-edge-identity.test.ts
@@ -0,0 +1,45 @@
+/**
+ * Relationship-identity discriminant (issue #70): a plain endpoint-pair MERGE collapses
+ * legitimately-distinct edges of one type between the same two nodes — the DDG carries one edge
+ * per variable (plus the prov split), and a conditional's true/false CFG_NEXT pair shares its
+ * endpoints. Discriminated families MERGE on `{_k: row.k}` so each survives; undiscriminated
+ * families keep the plain endpoint-pair MERGE.
+ */
+import { describe, expect, test } from "bun:test";
+import { renderCypher } from "../src/build/neo4j";
+import { RowBuilder } from "../src/build/neo4j/rows";
+
+function twoVarDdgRows() {
+  const b = new RowBuilder();
+  const a = b.node(["CanNode", "BodyNode"], "id", "can://ts/app/f.ts/f()@1:0", {});
+  const c = b.node(["CanNode", "BodyNode"], "id", "can://ts/app/f.ts/f()@2:0", {});
+  b.edge("DDG", a, c, { var: "x", prov: ["reaching-defs"] }, "x|reaching-defs");
+  b.edge("DDG", a, c, { var: "y", prov: ["reaching-defs"] }, "y|reaching-defs");
+  b.edge("CDG", a, c); // undiscriminated control family stays a plain MERGE
+  return b.finish();
+}
+
+describe("edge identity discriminant (_k)", () => {
+  test("per-var DDG edges between one endpoint pair both survive rendering", () => {
+    const cypher = renderCypher(twoVarDdgRows(), "app");
+    expect(cypher).toContain("MERGE (a)-[r:DDG {_k: row.k}]->(b)");
+    expect(cypher).toContain("k: 'x|reaching-defs'");
+    expect(cypher).toContain("k: 'y|reaching-defs'");
+  });
+
+  test("undiscriminated families keep the plain endpoint-pair MERGE", () => {
+    const cypher = renderCypher(twoVarDdgRows(), "app");
+    expect(cypher).toContain("MERGE (a)-[r:CDG]->(b)");
+    expect(cypher).not.toContain("MERGE (a)-[r:CDG {_k");
+  });
+
+  test("row model carries the discriminant only when set", () => {
+    const rows = twoVarDdgRows();
+    const ddg = rows.edges.filter((e) => e.type === "DDG");
+    const cdg = rows.edges.filter((e) => e.type === "CDG");
+    expect(ddg.map((e) => e.key).sort()).toEqual(["x|reaching-defs", "y|reaching-defs"]);
+    expect(cdg[0].key).toBeUndefined();
+    // distinct identity per (type, endpoints, key): nothing deduplicates the pair
+    expect(ddg.length).toBe(2);
+  });
+});

From 0869206b1b4968b0e8c8d27599e67b0430072217 Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Wed, 15 Jul 2026 00:25:19 -0400
Subject: [PATCH 23/32] test(schema): pin DDG/CFG_NEXT writer parity on the
 real L4 projection (#70)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The issue #27 parity gate compares rows to JSON before the writers run, so a
missing or non-unique _k would still collapse edges in the live graph without
failing any test (the bolt container suite pushes at -a 1, where the
discriminated families are empty). Assert on the L4 dataflow projection that
every DDG/CFG_NEXT row carries a key, that (from, to, _k) tuples are fully
distinct, and — non-vacuously — that both families really produce parallel
edges between one endpoint pair on this fixture.
---
 test/schema-v2.test.ts | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/test/schema-v2.test.ts b/test/schema-v2.test.ts
index 403e5c5..c9f533a 100644
--- a/test/schema-v2.test.ts
+++ b/test/schema-v2.test.ts
@@ -786,4 +786,30 @@ describe("neo4j ↔ json count parity — full depth (issue #27)", () => {
     expect(resolvesTo).toBe(resolvesToCount(monoApp4));
     expect(typedOverlay + containment + resolvesTo + heritage).toBe(monoRows.edges.length);
   });
+
+  test("DDG/CFG_NEXT parity survives the writers: every row keyed, keys fully discriminate (issue #70)", () => {
+    // The per-family counts above compare rows to JSON *before* the writers run. Both writers MERGE
+    // discriminated families on `(endpoints, _k)` — so the live graph materializes exactly one
+    // relationship per distinct (from, to, key) tuple. If any row lacked a key, or two parallel
+    // rows shared one, MERGE would silently collapse them and row-level parity would never notice.
+    // This pins the discriminant on the real L4 projection, not a synthetic fixture.
+    for (const type of ["DDG", "CFG_NEXT"] as const) {
+      const rows = monoRows.edges.filter((e) => e.type === type);
+      expect(rows.length).toBeGreaterThan(0);
+      expect(rows.every((e) => e.key !== undefined)).toBe(true);
+      const distinct = new Set(rows.map((e) => `${e.from.value}${e.to.value}${e.key}`));
+      expect(distinct.size).toBe(rows.length);
+    }
+    // Non-vacuous: the fixture really produces parallel edges between one endpoint pair for both
+    // families (per-var DDG; a conditional's true/false CFG_NEXT pair) — the collapse the `_k`
+    // discriminant exists to prevent. Guards against the fixture ever losing that shape.
+    for (const type of ["DDG", "CFG_NEXT"] as const) {
+      const pairs = new Map<string, number>();
+      for (const e of monoRows.edges.filter((e) => e.type === type)) {
+        const pair = `${e.from.value}${e.to.value}`;
+        pairs.set(pair, (pairs.get(pair) ?? 0) + 1);
+      }
+      expect(Math.max(...pairs.values())).toBeGreaterThanOrEqual(2);
+    }
+  });
 });

From 90ef63a5dfdcf14cbd076214ea1dd85209ce9d1f Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Wed, 15 Jul 2026 00:43:01 -0400
Subject: [PATCH 24/32] fix(call-graph): resolve checker-known external targets
 to phantoms (closes #53)

---
 src/schema/signatures.ts                      | 59 ++++++++++---
 src/semantic_analysis/callGraph.ts            | 20 ++++-
 test/external-resolution.test.ts              | 85 +++++++++++++++++++
 .../fixtures/sample-app/src/external-calls.ts | 34 ++++++++
 4 files changed, 186 insertions(+), 12 deletions(-)
 create mode 100644 test/external-resolution.test.ts
 create mode 100644 test/fixtures/sample-app/src/external-calls.ts

diff --git a/src/schema/signatures.ts b/src/schema/signatures.ts
index cf91b74..0ea9a4f 100644
--- a/src/schema/signatures.ts
+++ b/src/schema/signatures.ts
@@ -77,25 +77,51 @@ export function resolveCalleeDecl(call: Node): Node | undefined {
   return decls && decls.length ? decls[0] : undefined;
 }
 
+/** Where a checker-resolved declaration lives: in-project, a node_modules package, or the TS stdlib. */
+function externalHomeOf(decl: Node): { module: string } | null {
+  const p = decl.getSourceFile().getFilePath();
+  // Take the LAST node_modules/<pkg> segment, not the first: under pnpm's virtual store a real
+  // path looks like `node_modules/.pnpm/<pkg>@<ver>/node_modules/<pkg>/...`, so the first match
+  // would capture `.pnpm` instead of the package. The innermost occurrence is always the real home.
+  const matches = [...p.matchAll(/node_modules\/(@[^/]+\/[^/]+|[^/]+)/g)];
+  if (matches.length) {
+    const pkg = matches[matches.length - 1][1];
+    // `@types/<pkg>` ships only type declarations FOR `<pkg>` — treat the runtime package as home
+    // so a package's identity is stable regardless of whether its types are bundled or DT-sourced.
+    return { module: pkg.startsWith("@types/") ? pkg.slice("@types/".length) : pkg };
+  }
+  if (/typescript\/lib\/lib\..*\.d\.ts$/.test(p)) return { module: "(builtin)" };
+  return null;
+}
+
 /**
- * Resolve a call/new site to the signature of an existing symbol-table callable, or null.
- * `allSignatures` gates the result so an edge can never dangle into a non-recorded declaration
- * (e.g. one in node_modules).
+ * Resolve a call/new site to the signature of an existing symbol-table callable, or an external
+ * descriptor when the checker resolved the call to a declaration outside the project (a
+ * node_modules package or the TS stdlib), or null when neither applies.
+ * `allSignatures` gates in-project resolution so an edge can never dangle into a non-recorded
+ * declaration.
  */
 export function resolveCalleeSignature(
   call: Node,
   root: string,
   allSignatures: Set<string>,
-): { signature: string; isConstructor: boolean } | null {
+): { signature: string; isConstructor: boolean; external?: { module: string; member: string } } | null {
   const decl = resolveCalleeDecl(call);
   if (!decl) return null;
 
   // `new X()` / a bare class reference → the class's (possibly synthesized) constructor.
   if (Node.isClassDeclaration(decl) || Node.isClassExpression(decl)) {
     const csig = computeSignatureForDecl(decl, root);
-    if (!csig) return null;
-    const target = constructorSignatureOf(csig);
-    return allSignatures.has(target) ? { signature: target, isConstructor: true } : null;
+    if (csig) {
+      const target = constructorSignatureOf(csig);
+      if (allSignatures.has(target)) return { signature: target, isConstructor: true };
+    }
+    const home = externalHomeOf(decl);
+    if (home) {
+      const member = classLikeName(decl);
+      return { signature: `${home.module}.${member}`, isConstructor: true, external: { module: home.module, member } };
+    }
+    return null;
   }
 
   // const f = () => {} / function expression bound to a variable.
@@ -103,16 +129,27 @@ export function resolveCalleeSignature(
     const init = decl.getInitializer();
     if (init && (Node.isArrowFunction(init) || Node.isFunctionExpression(init))) {
       const s = computeSignatureForDecl(decl, root);
-      return s && allSignatures.has(s) ? { signature: s, isConstructor: false } : null;
+      if (s && allSignatures.has(s)) return { signature: s, isConstructor: false };
+      const home = externalHomeOf(decl);
+      if (home) {
+        const member = safeName(decl);
+        return { signature: `${home.module}.${member}`, isConstructor: false, external: { module: home.module, member } };
+      }
+      return null;
     }
     return null;
   }
 
   if (isCallableDecl(decl)) {
     const s = computeSignatureForDecl(decl, root);
-    return s && allSignatures.has(s)
-      ? { signature: s, isConstructor: Node.isConstructorDeclaration(decl) }
-      : null;
+    const isConstructor = Node.isConstructorDeclaration(decl);
+    if (s && allSignatures.has(s)) return { signature: s, isConstructor };
+    const home = externalHomeOf(decl);
+    if (home) {
+      const member = safeName(decl as never);
+      return { signature: `${home.module}.${member}`, isConstructor, external: { module: home.module, member } };
+    }
+    return null;
   }
   return null;
 }
diff --git a/src/semantic_analysis/callGraph.ts b/src/semantic_analysis/callGraph.ts
index c85fb9a..b1216dd 100644
--- a/src/semantic_analysis/callGraph.ts
+++ b/src/semantic_analysis/callGraph.ts
@@ -63,7 +63,10 @@ export function buildCallGraph(
   for (const node of callExprIndex.values()) {
     if (Node.isNewExpression(node)) {
       const r = resolveCalleeSignature(node, root, allSignatures);
-      if (r?.isConstructor) instantiated.add(r.signature.slice(0, -".constructor".length));
+      // External constructors are never project subtypes, so they never feed RTA expansion; their
+      // signature (`${module}.${member}`) also doesn't carry the `.constructor` suffix a dot-split
+      // below would assume.
+      if (r?.isConstructor && !r.external) instantiated.add(r.signature.slice(0, -".constructor".length));
     }
   }
 
@@ -128,6 +131,21 @@ export function buildCallGraph(
         continue;
       }
       const r = resolveCalleeSignature(node, root, allSignatures);
+      if (r?.external) {
+        // Checker-known external target (a node_modules package or the TS stdlib) — same gate as
+        // the import-index fallback below: phantom edges are opt-in via `phantoms`.
+        if (phantoms) {
+          if (!external_symbols[r.signature]) {
+            external_symbols[r.signature] = { name: r.external.member, module: r.external.module };
+          }
+          site.callee_signature = r.signature;
+          addPhantomEdge(caller.signature, r.signature, r.external.module);
+          phantomCount++;
+        } else {
+          unresolved++;
+        }
+        continue; // never RTA-expand an external target: no dot-split on a ${module}.${member} id.
+      }
       if (!r) {
         // Phantom fallback: attribute the call to an imported/required external member.
         if (phantoms) {
diff --git a/test/external-resolution.test.ts b/test/external-resolution.test.ts
new file mode 100644
index 0000000..afbaaf8
--- /dev/null
+++ b/test/external-resolution.test.ts
@@ -0,0 +1,85 @@
+/**
+ * #53 — checker-known external/library calls resolve to `:External` phantoms instead of being
+ * dropped. `resolveCalleeSignature` (src/schema/signatures.ts) already asks the ts-morph checker
+ * for the callee's declaration; before this fix it only kept the result when the declaration lived
+ * in-project (gated by `allSignatures`), silently discarding anything the checker resolved into
+ * node_modules or the TS stdlib. The fixture (`external-calls.ts`) exercises the two cases the
+ * pre-existing import-index phantom fallback (phantoms.ts) can't reach on its own: a member call on
+ * a receiver that is itself external-typed but not an import binding (`cmd.name()`/`cmd.parse()` —
+ * `cmd` is a local `const`, not an `import`), and a bare stdlib global with no import at all (`eval`).
+ */
+import { describe, expect, test } from "bun:test";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { analyze } from "../src/core";
+import type { AnalysisOptions } from "../src/options";
+import type { TSApplication, TSCallsite } from "../src/schema";
+
+const FIXTURE = path.resolve(import.meta.dir, "fixtures/sample-app");
+
+function options(): AnalysisOptions {
+  return {
+    input: FIXTURE,
+    output: null,
+    emit: "json",
+    appName: null,
+    neo4jUri: null,
+    neo4jUser: "neo4j",
+    neo4jPassword: "",
+    neo4jDatabase: null,
+    analysisLevel: 2,
+    graphs: [],
+    graphFieldDepth: 3,
+    jobs: 1,
+    targetFiles: null,
+    skipTests: true,
+    eager: true,
+    noBuild: true,
+    phantoms: true,
+    callGraphProvider: "tsc",
+    cacheDir: null,
+    verbosity: 0,
+  };
+}
+
+async function run(): Promise<TSApplication> {
+  const cacheDir = fs.mkdtempSync(path.join(os.tmpdir(), "cants-ext-test-"));
+  try {
+    return await analyze({ ...options(), cacheDir });
+  } finally {
+    fs.rmSync(cacheDir, { recursive: true, force: true });
+  }
+}
+
+/** Every call site recorded on every top-level function of one module file. */
+function callsIn(app: TSApplication, fileKey: string): TSCallsite[] {
+  const mod = app.symbol_table[fileKey];
+  const out: TSCallsite[] = [];
+  for (const fn of Object.values(mod.functions)) out.push(...fn.call_sites);
+  return out;
+}
+
+describe("external call resolution (#53)", () => {
+  test("checker-resolved external targets become external_symbols with callee backfilled", async () => {
+    const app = await run();
+
+    const ext = Object.keys(app.external_symbols ?? {});
+    // node:fs.readFileSync — a bare named-import call, already reachable via the pre-existing
+    // import-index fallback (unaffected by #53; asserted here for shape parity).
+    expect(ext.some((s) => s.includes("node:fs") && s.includes("readFileSync"))).toBe(true);
+    // `new Command()` — also a bare named-import identifier, so the import-index fallback already
+    // catches it too. The genuinely new case is `cmd.name()/.description()/.parse()`: member calls
+    // on `cmd`, a local `const`, not an import binding — the syntactic index has nothing to key off
+    // of, so only checker-based resolution (this fix) reaches them.
+    expect(ext.some((s) => s.startsWith("commander"))).toBe(true);
+    expect(ext.some((s) => /^commander\.(name|description|parse)$/.test(s))).toBe(true);
+    // a TS-stdlib global (eval, from lib.*.d.ts) with no import at all — checker-resolved, new in #53.
+    expect(ext.some((s) => s.endsWith(".eval"))).toBe(true);
+
+    const calls = callsIn(app, "src/external-calls.ts");
+    expect(calls.length).toBeGreaterThan(0);
+    const resolved = calls.filter((c) => c.callee_signature != null);
+    expect(resolved.length / calls.length).toBeGreaterThanOrEqual(0.75);
+  });
+});
diff --git a/test/fixtures/sample-app/src/external-calls.ts b/test/fixtures/sample-app/src/external-calls.ts
new file mode 100644
index 0000000..2deda5b
--- /dev/null
+++ b/test/fixtures/sample-app/src/external-calls.ts
@@ -0,0 +1,34 @@
+// Exercises checker-known external targets (#53): calls the tsc resolver CAN map to a declaration,
+// but that declaration lives outside the project (a node_modules package or the TS stdlib), so the
+// resolver's `allSignatures` gate used to drop them. These are cases the import-index phantom
+// fallback (phantoms.ts) can't reach on its own:
+//   - a member call on a receiver that is itself external-typed but NOT an import binding
+//     (`cmd` below is a local `const`, not an `import`, so the syntactic index has nothing
+//     to key off of — only the checker knows its type comes from node_modules).
+//   - a bare global from lib.*.d.ts with no import at all (`eval`).
+import { readFileSync } from "node:fs";
+import { Command } from "commander";
+
+/** named-import bare call → phantom via the existing import-index fallback (unchanged by #53). */
+export function readsConfig(): string {
+  return readFileSync("config.json", "utf8");
+}
+
+/**
+ * `new Command()` is a bare named-import identifier, so the pre-existing import-index fallback
+ * already resolves it — unaffected by #53. The member calls below are the new case: `cmd` is a
+ * local `const`, not an import binding, so the syntactic index has nothing to key off of and only
+ * checker-based resolution (this fix) can classify `cmd.name`/`cmd.description`/`cmd.parse` as
+ * external.
+ */
+export function makesCommand(): Command {
+  const cmd = new Command();
+  cmd.name("cli").description("demo");
+  cmd.parse(["node", "cli.js"]);
+  return cmd;
+}
+
+/** a lib.*.d.ts global with no import at all — only the checker can classify its home. */
+export function unsafeEval(raw: string): unknown {
+  return eval(raw);
+}

From 9d4a4c3e7a285b5589cd7442fb5f01f33286279d Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Wed, 15 Jul 2026 00:51:20 -0400
Subject: [PATCH 25/32] fix(call-graph): canonical node:<mod> identity for
 @types/node externals (#53)

---
 src/schema/signatures.ts                      | 25 +++++---
 test/external-resolution.test.ts              | 61 ++++++++++++++++++-
 .../fixtures/sample-app/src/external-calls.ts | 21 +++++--
 3 files changed, 91 insertions(+), 16 deletions(-)

diff --git a/src/schema/signatures.ts b/src/schema/signatures.ts
index 0ea9a4f..43f0f08 100644
--- a/src/schema/signatures.ts
+++ b/src/schema/signatures.ts
@@ -78,20 +78,29 @@ export function resolveCalleeDecl(call: Node): Node | undefined {
 }
 
 /** Where a checker-resolved declaration lives: in-project, a node_modules package, or the TS stdlib. */
-function externalHomeOf(decl: Node): { module: string } | null {
+export function externalHomeOf(decl: Node): { module: string } | null {
   const p = decl.getSourceFile().getFilePath();
+  // TS stdlib (lib.es5.d.ts, lib.dom.d.ts, ...) — checked BEFORE the generic node_modules match,
+  // which would otherwise claim these files as belonging to the package `typescript`.
+  if (/typescript\/lib\/lib\..*\.d\.ts$/.test(p)) return { module: "(builtin)" };
   // Take the LAST node_modules/<pkg> segment, not the first: under pnpm's virtual store a real
   // path looks like `node_modules/.pnpm/<pkg>@<ver>/node_modules/<pkg>/...`, so the first match
   // would capture `.pnpm` instead of the package. The innermost occurrence is always the real home.
   const matches = [...p.matchAll(/node_modules\/(@[^/]+\/[^/]+|[^/]+)/g)];
-  if (matches.length) {
-    const pkg = matches[matches.length - 1][1];
-    // `@types/<pkg>` ships only type declarations FOR `<pkg>` — treat the runtime package as home
-    // so a package's identity is stable regardless of whether its types are bundled or DT-sourced.
-    return { module: pkg.startsWith("@types/") ? pkg.slice("@types/".length) : pkg };
+  if (!matches.length) return null;
+  const last = matches[matches.length - 1];
+  const pkg = last[1];
+  // DefinitelyTyped's node typings model the Node builtins one file per module — name the target
+  // by its import specifier (`node:fs`, `node:stream/consumers`) so this path and the import-index
+  // fallback (which keys phantoms by specifier) agree on one identity per logical callee, instead
+  // of collapsing every builtin under a single `node` module.
+  if (pkg === "@types/node") {
+    const rel = p.slice((last.index as number) + last[0].length + 1).replace(/(\.d)?\.ts$/, "");
+    return { module: rel === "index" ? "node" : `node:${rel}` };
   }
-  if (/typescript\/lib\/lib\..*\.d\.ts$/.test(p)) return { module: "(builtin)" };
-  return null;
+  // Any other `@types/<pkg>` ships only type declarations FOR `<pkg>` — treat the runtime package
+  // as home so a package's identity is stable whether its types are bundled or DT-sourced.
+  return { module: pkg.startsWith("@types/") ? pkg.slice("@types/".length) : pkg };
 }
 
 /**
diff --git a/test/external-resolution.test.ts b/test/external-resolution.test.ts
index afbaaf8..c36463f 100644
--- a/test/external-resolution.test.ts
+++ b/test/external-resolution.test.ts
@@ -12,9 +12,11 @@ import { describe, expect, test } from "bun:test";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { type Node, Project } from "ts-morph";
 import { analyze } from "../src/core";
 import type { AnalysisOptions } from "../src/options";
 import type { TSApplication, TSCallsite } from "../src/schema";
+import { externalHomeOf } from "../src/schema/signatures";
 
 const FIXTURE = path.resolve(import.meta.dir, "fixtures/sample-app");
 
@@ -68,12 +70,15 @@ describe("external call resolution (#53)", () => {
     // node:fs.readFileSync — a bare named-import call, already reachable via the pre-existing
     // import-index fallback (unaffected by #53; asserted here for shape parity).
     expect(ext.some((s) => s.includes("node:fs") && s.includes("readFileSync"))).toBe(true);
-    // `new Command()` — also a bare named-import identifier, so the import-index fallback already
-    // catches it too. The genuinely new case is `cmd.name()/.description()/.parse()`: member calls
-    // on `cmd`, a local `const`, not an import binding — the syntactic index has nothing to key off
+    // `new Command()` — checker-resolved to commander's ClassDeclaration (commander self-types);
+    // the import-index fallback would name it identically, so both paths agree on one identity.
+    // The genuinely checker-only case is `cmd.name()/.description()/.parse()`: member calls on
+    // `cmd`, a local `const`, not an import binding — the syntactic index has nothing to key off
     // of, so only checker-based resolution (this fix) reaches them.
     expect(ext.some((s) => s.startsWith("commander"))).toBe(true);
     expect(ext.some((s) => /^commander\.(name|description|parse)$/.test(s))).toBe(true);
+    // default-import member call (`neo4j.driver(...)`) → external neo4j-driver.driver.
+    expect(ext.some((s) => s.startsWith("neo4j-driver") && s.includes("driver"))).toBe(true);
     // a TS-stdlib global (eval, from lib.*.d.ts) with no import at all — checker-resolved, new in #53.
     expect(ext.some((s) => s.endsWith(".eval"))).toBe(true);
 
@@ -83,3 +88,53 @@ describe("external call resolution (#53)", () => {
     expect(resolved.length / calls.length).toBeGreaterThanOrEqual(0.75);
   });
 });
+
+// ---- externalHomeOf unit tests: declaration path → module identity ---------------------------
+// Each case plants a declaration at a synthetic node_modules path in an in-memory ts-morph
+// project and asserts the module identity `externalHomeOf` derives from that path alone.
+function declAt(filePath: string): Node {
+  const project = new Project({ useInMemoryFileSystem: true });
+  const sf = project.createSourceFile(filePath, "export declare function f(): void;");
+  return sf.getFunctionOrThrow("f");
+}
+
+describe("externalHomeOf — declaration home classification (#53)", () => {
+  test("@types/node files map to their node: specifier, not a collapsed `node` module", () => {
+    expect(externalHomeOf(declAt("/proj/node_modules/@types/node/fs.d.ts"))).toEqual({ module: "node:fs" });
+    // nested builtin modules keep their subpath
+    expect(externalHomeOf(declAt("/proj/node_modules/@types/node/stream/consumers.d.ts"))).toEqual({
+      module: "node:stream/consumers",
+    });
+    // the root index (globals like `process`) has no per-module specifier → plain `node`
+    expect(externalHomeOf(declAt("/proj/node_modules/@types/node/index.d.ts"))).toEqual({ module: "node" });
+  });
+
+  test("other @types/<pkg> collapse onto the runtime package", () => {
+    expect(externalHomeOf(declAt("/proj/node_modules/@types/commander/index.d.ts"))).toEqual({ module: "commander" });
+  });
+
+  test("pnpm virtual-store paths resolve to the innermost package, not .pnpm", () => {
+    expect(externalHomeOf(declAt("/proj/node_modules/.pnpm/zod@3.24.1/node_modules/zod/index.d.ts"))).toEqual({
+      module: "zod",
+    });
+    expect(
+      externalHomeOf(declAt("/proj/node_modules/.pnpm/@types+node@22.0.0/node_modules/@types/node/fs.d.ts")),
+    ).toEqual({ module: "node:fs" });
+  });
+
+  test("scoped packages keep their full @scope/name", () => {
+    expect(externalHomeOf(declAt("/proj/node_modules/@scope/pkg/dist/index.d.ts"))).toEqual({ module: "@scope/pkg" });
+  });
+
+  test("the TS stdlib maps to (builtin), even though it lives under node_modules/typescript", () => {
+    expect(externalHomeOf(declAt("/proj/node_modules/typescript/lib/lib.es5.d.ts"))).toEqual({ module: "(builtin)" });
+    // non-lib typescript files are just the `typescript` package
+    expect(externalHomeOf(declAt("/proj/node_modules/typescript/lib/typescript.d.ts"))).toEqual({
+      module: "typescript",
+    });
+  });
+
+  test("in-project declarations have no external home", () => {
+    expect(externalHomeOf(declAt("/proj/src/app.ts"))).toBeNull();
+  });
+});
diff --git a/test/fixtures/sample-app/src/external-calls.ts b/test/fixtures/sample-app/src/external-calls.ts
index 2deda5b..a6b890e 100644
--- a/test/fixtures/sample-app/src/external-calls.ts
+++ b/test/fixtures/sample-app/src/external-calls.ts
@@ -8,6 +8,7 @@
 //   - a bare global from lib.*.d.ts with no import at all (`eval`).
 import { readFileSync } from "node:fs";
 import { Command } from "commander";
+import neo4j from "neo4j-driver";
 
 /** named-import bare call → phantom via the existing import-index fallback (unchanged by #53). */
 export function readsConfig(): string {
@@ -15,11 +16,12 @@ export function readsConfig(): string {
 }
 
 /**
- * `new Command()` is a bare named-import identifier, so the pre-existing import-index fallback
- * already resolves it — unaffected by #53. The member calls below are the new case: `cmd` is a
- * local `const`, not an import binding, so the syntactic index has nothing to key off of and only
- * checker-based resolution (this fix) can classify `cmd.name`/`cmd.description`/`cmd.parse` as
- * external.
+ * `new Command()` resolves through the checker path (#53): commander self-types, so the checker
+ * lands on its ClassDeclaration in node_modules → external constructor `commander.Command`. The
+ * import-index fallback would name it identically (named import of `Command` from `commander`),
+ * so both paths agree — the checker path just wins by running first. The member calls below are
+ * the case ONLY the checker can reach: `cmd` is a local `const`, not an import binding, so the
+ * syntactic index has nothing to key off of for `cmd.name`/`cmd.description`/`cmd.parse`.
  */
 export function makesCommand(): Command {
   const cmd = new Command();
@@ -28,6 +30,15 @@ export function makesCommand(): Command {
   return cmd;
 }
 
+/**
+ * default-import member call → external `neo4j-driver.driver`. (No direct dependency of this repo
+ * has a *callable* default export — neo4j-driver's default is an object — so a default-import
+ * member call stands in for the `express()`-style bare default call.)
+ */
+export function makesDriver(): unknown {
+  return neo4j.driver("bolt://localhost");
+}
+
 /** a lib.*.d.ts global with no import at all — only the checker can classify its home. */
 export function unsafeEval(raw: string): unknown {
   return eval(raw);

From de55426f410b7ea2046d3961967cf5714f37a9e2 Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Wed, 15 Jul 2026 01:05:41 -0400
Subject: [PATCH 26/32] =?UTF-8?q?feat(neo4j)!:=20TS-prefixed=20labels=20an?=
 =?UTF-8?q?d=20TS=5F=20relationship=20types=20=E2=80=94=20final=202.0.0=20?=
 =?UTF-8?q?vocabulary=20(closes=20#66,=20closes=20#9,=20closes=20#10)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md                        |   7 +-
 schema.neo4j.json                | 174 ++++++++++++++-----------------
 src/build/neo4j/bolt.ts          |  14 +--
 src/build/neo4j/cypher.ts        |   4 +-
 src/build/neo4j/index.ts         |   2 +-
 src/build/neo4j/project.ts       |  84 +++++++--------
 src/build/neo4j/rows.ts          |  13 +--
 src/build/neo4j/schema.ts        | 117 ++++++++-------------
 test/external-resolution.test.ts |   2 +-
 test/neo4j-bolt.test.ts          |   6 +-
 test/neo4j-edge-identity.test.ts |  20 ++--
 test/neo4j-schema.test.ts        |  41 +++-----
 test/neo4j-twins.test.ts         |  48 ---------
 test/schema-v2.test.ts           |  44 ++++----
 test/synthesized-nodes.test.ts   |   8 +-
 15 files changed, 238 insertions(+), 346 deletions(-)
 delete mode 100644 test/neo4j-twins.test.ts

diff --git a/README.md b/README.md
index 5d96769..55d1a92 100644
--- a/README.md
+++ b/README.md
@@ -308,9 +308,10 @@ Levels 1/2 are unaffected: nothing in level 3 runs unless `-a 3` is requested.
 ### Neo4j graph
 
 `--emit neo4j` projects the **same v2 tree** into a labeled property graph: every node keyed by its
-`can://` id under a shared `:CanNode` merge label (+ a specific kind label), containment as
-`HAS_MODULE`/`DECLARES`/`HAS_METHOD`/`HAS_FIELD`/`HAS_BODY_NODE` edges, and the overlays (`CALLS`,
-`CFG_NEXT`, `CDG`, `DDG`, `SUMMARY`, `PARAM_IN`, `PARAM_OUT`) as typed relationships. The graph is
+`can://` id under a shared `:CanNode` merge label (+ a `TS`-prefixed specific kind label, e.g.
+`:TSModule`, `:TSCallable`), containment as `TS_HAS_MODULE`/`TS_DECLARES`/`TS_HAS_METHOD`/
+`TS_HAS_FIELD`/`TS_HAS_BODY_NODE` edges, and the overlays (`TS_CALLS`, `TS_CFG_NEXT`, `TS_CDG`,
+`TS_DDG`, `TS_SUMMARY`, `TS_PARAM_IN`, `TS_PARAM_OUT`) as typed relationships. The graph is
 **always full-depth** — analysis levels gate the JSON path only, so combining `-a`/`--graphs` with
 `--emit neo4j` is an error:
 
diff --git a/schema.neo4j.json b/schema.neo4j.json
index 68dfa07..bb700cd 100644
--- a/schema.neo4j.json
+++ b/schema.neo4j.json
@@ -4,7 +4,7 @@
   "marker_labels": [],
   "node_labels": [
     {
-      "label": "Application",
+      "label": "TSApplication",
       "mergeLabel": "Application",
       "key": "id",
       "properties": {
@@ -18,7 +18,7 @@
       }
     },
     {
-      "label": "Module",
+      "label": "TSModule",
       "mergeLabel": "CanNode",
       "key": "id",
       "properties": {
@@ -34,7 +34,7 @@
       }
     },
     {
-      "label": "Class",
+      "label": "TSClass",
       "mergeLabel": "CanNode",
       "key": "id",
       "properties": {
@@ -53,7 +53,7 @@
       }
     },
     {
-      "label": "Interface",
+      "label": "TSInterface",
       "mergeLabel": "CanNode",
       "key": "id",
       "properties": {
@@ -70,7 +70,7 @@
       }
     },
     {
-      "label": "Enum",
+      "label": "TSEnum",
       "mergeLabel": "CanNode",
       "key": "id",
       "properties": {
@@ -87,7 +87,7 @@
       }
     },
     {
-      "label": "TypeAlias",
+      "label": "TSTypeAlias",
       "mergeLabel": "CanNode",
       "key": "id",
       "properties": {
@@ -104,7 +104,7 @@
       }
     },
     {
-      "label": "Namespace",
+      "label": "TSNamespace",
       "mergeLabel": "CanNode",
       "key": "id",
       "properties": {
@@ -120,7 +120,7 @@
       }
     },
     {
-      "label": "Callable",
+      "label": "TSCallable",
       "mergeLabel": "CanNode",
       "key": "id",
       "properties": {
@@ -145,7 +145,7 @@
       }
     },
     {
-      "label": "Field",
+      "label": "TSField",
       "mergeLabel": "CanNode",
       "key": "id",
       "properties": {
@@ -159,7 +159,7 @@
       }
     },
     {
-      "label": "BodyNode",
+      "label": "TSBodyNode",
       "mergeLabel": "CanNode",
       "key": "id",
       "properties": {
@@ -174,7 +174,7 @@
       }
     },
     {
-      "label": "External",
+      "label": "TSExternal",
       "mergeLabel": "CanNode",
       "key": "id",
       "properties": {
@@ -186,7 +186,7 @@
       }
     },
     {
-      "label": "AnonymousCallable",
+      "label": "TSAnonymousCallable",
       "mergeLabel": "CanNode",
       "key": "id",
       "properties": {
@@ -202,90 +202,90 @@
   ],
   "relationship_types": [
     {
-      "type": "HAS_MODULE",
+      "type": "TS_HAS_MODULE",
       "from": [
-        "Application"
+        "TSApplication"
       ],
       "to": [
-        "Module"
+        "TSModule"
       ],
       "properties": {}
     },
     {
-      "type": "DECLARES",
+      "type": "TS_DECLARES",
       "from": [
-        "Module",
-        "Namespace",
-        "Callable"
+        "TSModule",
+        "TSNamespace",
+        "TSCallable"
       ],
       "to": [
-        "Class",
-        "Interface",
-        "Enum",
-        "TypeAlias",
-        "Namespace",
-        "Callable"
+        "TSClass",
+        "TSInterface",
+        "TSEnum",
+        "TSTypeAlias",
+        "TSNamespace",
+        "TSCallable"
       ],
       "properties": {}
     },
     {
-      "type": "HAS_METHOD",
+      "type": "TS_HAS_METHOD",
       "from": [
-        "Class",
-        "Interface"
+        "TSClass",
+        "TSInterface"
       ],
       "to": [
-        "Callable"
+        "TSCallable"
       ],
       "properties": {}
     },
     {
-      "type": "HAS_FIELD",
+      "type": "TS_HAS_FIELD",
       "from": [
-        "Module",
-        "Class",
-        "Interface",
-        "Enum",
-        "Namespace"
+        "TSModule",
+        "TSClass",
+        "TSInterface",
+        "TSEnum",
+        "TSNamespace"
       ],
       "to": [
-        "Field"
+        "TSField"
       ],
       "properties": {}
     },
     {
-      "type": "HAS_BODY_NODE",
+      "type": "TS_HAS_BODY_NODE",
       "from": [
-        "Callable",
-        "AnonymousCallable"
+        "TSCallable",
+        "TSAnonymousCallable"
       ],
       "to": [
-        "BodyNode"
+        "TSBodyNode"
       ],
       "properties": {}
     },
     {
-      "type": "RESOLVES_TO",
+      "type": "TS_RESOLVES_TO",
       "from": [
-        "BodyNode"
+        "TSBodyNode"
       ],
       "to": [
-        "Callable",
-        "External",
-        "AnonymousCallable"
+        "TSCallable",
+        "TSExternal",
+        "TSAnonymousCallable"
       ],
       "properties": {}
     },
     {
-      "type": "CALLS",
+      "type": "TS_CALLS",
       "from": [
-        "Callable",
-        "AnonymousCallable"
+        "TSCallable",
+        "TSAnonymousCallable"
       ],
       "to": [
-        "Callable",
-        "External",
-        "AnonymousCallable"
+        "TSCallable",
+        "TSExternal",
+        "TSAnonymousCallable"
       ],
       "properties": {
         "weight": "integer",
@@ -293,12 +293,12 @@
       }
     },
     {
-      "type": "CFG_NEXT",
+      "type": "TS_CFG_NEXT",
       "from": [
-        "BodyNode"
+        "TSBodyNode"
       ],
       "to": [
-        "BodyNode"
+        "TSBodyNode"
       ],
       "properties": {
         "kind": "string",
@@ -306,22 +306,22 @@
       }
     },
     {
-      "type": "CDG",
+      "type": "TS_CDG",
       "from": [
-        "BodyNode"
+        "TSBodyNode"
       ],
       "to": [
-        "BodyNode"
+        "TSBodyNode"
       ],
       "properties": {}
     },
     {
-      "type": "DDG",
+      "type": "TS_DDG",
       "from": [
-        "BodyNode"
+        "TSBodyNode"
       ],
       "to": [
-        "BodyNode"
+        "TSBodyNode"
       ],
       "properties": {
         "var": "string",
@@ -330,61 +330,61 @@
       }
     },
     {
-      "type": "SUMMARY",
+      "type": "TS_SUMMARY",
       "from": [
-        "BodyNode"
+        "TSBodyNode"
       ],
       "to": [
-        "BodyNode"
+        "TSBodyNode"
       ],
       "properties": {
         "var": "string"
       }
     },
     {
-      "type": "PARAM_IN",
+      "type": "TS_PARAM_IN",
       "from": [
-        "BodyNode"
+        "TSBodyNode"
       ],
       "to": [
-        "BodyNode"
+        "TSBodyNode"
       ],
       "properties": {
         "var": "string"
       }
     },
     {
-      "type": "PARAM_OUT",
+      "type": "TS_PARAM_OUT",
       "from": [
-        "BodyNode"
+        "TSBodyNode"
       ],
       "to": [
-        "BodyNode"
+        "TSBodyNode"
       ],
       "properties": {
         "var": "string"
       }
     },
     {
-      "type": "EXTENDS",
+      "type": "TS_EXTENDS",
       "from": [
-        "Class",
-        "Interface"
+        "TSClass",
+        "TSInterface"
       ],
       "to": [
-        "Class",
-        "Interface"
+        "TSClass",
+        "TSInterface"
       ],
       "properties": {}
     },
     {
-      "type": "IMPLEMENTS",
+      "type": "TS_IMPLEMENTS",
       "from": [
-        "Class"
+        "TSClass"
       ],
       "to": [
-        "Interface",
-        "Class"
+        "TSInterface",
+        "TSClass"
       ],
       "properties": {}
     }
@@ -394,21 +394,7 @@
     "CREATE CONSTRAINT cannode_id IF NOT EXISTS FOR (x:CanNode) REQUIRE x.id IS UNIQUE"
   ],
   "indexes": [
-    "CREATE INDEX callable_name IF NOT EXISTS FOR (c:Callable) ON (c.name)",
+    "CREATE INDEX callable_name IF NOT EXISTS FOR (c:TSCallable) ON (c.name)",
     "CREATE INDEX cannode_kind IF NOT EXISTS FOR (n:CanNode) ON (n.kind)"
-  ],
-  "label_twins": {
-    "Application": "TSApplication",
-    "Module": "TSModule",
-    "Class": "TSClass",
-    "Interface": "TSInterface",
-    "Enum": "TSEnum",
-    "TypeAlias": "TSTypeAlias",
-    "Namespace": "TSNamespace",
-    "Callable": "TSCallable",
-    "Field": "TSField",
-    "BodyNode": "TSBodyNode",
-    "External": "TSExternal",
-    "AnonymousCallable": "TSAnonymousCallable"
-  }
+  ]
 }
diff --git a/src/build/neo4j/bolt.ts b/src/build/neo4j/bolt.ts
index de1ee9a..d30d82b 100644
--- a/src/build/neo4j/bolt.ts
+++ b/src/build/neo4j/bolt.ts
@@ -11,8 +11,8 @@
  *  5. on a FULL run only, prune modules whose source file vanished.
  *
  * Nodes are MERGE-upserted, never blindly deleted, so a declaration another (unchanged) module
- * still references survives and its incoming edges stay valid. `:External`/`:Package`/`:Decorator`
- * are shared (no `_module`) and are MERGE-only.
+ * still references survives and its incoming edges stay valid. `:TSExternal` nodes are shared (no
+ * `_module`) and are MERGE-only.
  *
  * `neo4j-driver` is imported dynamically so it stays off the hot path and out of the default
  * (json) output entirely.
@@ -30,7 +30,7 @@ export interface BoltConfig {
   database: string | null;
 }
 
-const DESCENDANTS = "[:DECLARES|HAS_METHOD|HAS_FIELD|HAS_BODY_NODE*1..]";
+const DESCENDANTS = "[:TS_DECLARES|TS_HAS_METHOD|TS_HAS_FIELD|TS_HAS_BODY_NODE*1..]";
 const BATCH = 1000;
 
 export async function boltWriter(
@@ -68,7 +68,7 @@ export async function boltWriter(
     // 2. diff content_hash.
     const dbHash = new Map<string, string | null>();
     await withSession(session, async (s) => {
-      const res = await s.run("MATCH (m:Module) RETURN m._module AS k, m.content_hash AS h");
+      const res = await s.run("MATCH (m:TSModule) RETURN m._module AS k, m.content_hash AS h");
       for (const rec of res.records) dbHash.set(rec.get("k"), rec.get("h"));
     });
     const changed = new Set<string>();
@@ -112,7 +112,7 @@ export async function boltWriter(
       const present = [...byModule.keys()];
       await withSession(session, async (s) => {
         const res = await s.run(
-          `MATCH (m:Module) WHERE NOT m._module IN $present ` +
+          `MATCH (m:TSModule) WHERE NOT m._module IN $present ` +
             `OPTIONAL MATCH (m)-${DESCENDANTS}->(x) DETACH DELETE x, m RETURN count(m) AS pruned`,
           { present },
         );
@@ -193,8 +193,8 @@ function bucket<K, V>(map: Map<K, V[]>, key: K): V[] {
 }
 
 function hashOf(nodes: NodeRow[], _fileKey: string): string | undefined {
-  // Every node in `nodes` shares the same _module; the Module row (labels include "Module") carries the hash.
-  const mod = nodes.find((n) => n.labels.includes("Module"));
+  // Every node in `nodes` shares the same _module; the Module row (labels include "TSModule") carries the hash.
+  const mod = nodes.find((n) => n.labels.includes("TSModule"));
   const h = mod?.props.content_hash;
   return typeof h === "string" ? h : undefined;
 }
diff --git a/src/build/neo4j/cypher.ts b/src/build/neo4j/cypher.ts
index d66e5df..986d7b0 100644
--- a/src/build/neo4j/cypher.ts
+++ b/src/build/neo4j/cypher.ts
@@ -37,8 +37,8 @@ function wipe(appId: string): string {
   const id = cypherValue(appId);
   return [
     `MATCH (a:Application {id: ${id}})`,
-    "OPTIONAL MATCH (a)-[:HAS_MODULE]->(m:Module)",
-    "OPTIONAL MATCH (m)-[:DECLARES|HAS_METHOD|HAS_FIELD|HAS_BODY_NODE*1..]->(x)",
+    "OPTIONAL MATCH (a)-[:TS_HAS_MODULE]->(m:TSModule)",
+    "OPTIONAL MATCH (m)-[:TS_DECLARES|TS_HAS_METHOD|TS_HAS_FIELD|TS_HAS_BODY_NODE*1..]->(x)",
     "DETACH DELETE x, m, a;",
   ].join("\n");
 }
diff --git a/src/build/neo4j/index.ts b/src/build/neo4j/index.ts
index be460ec..1c70311 100644
--- a/src/build/neo4j/index.ts
+++ b/src/build/neo4j/index.ts
@@ -3,6 +3,6 @@
 export { project } from "./project";
 export { renderCypher } from "./cypher";
 export { boltWriter, type BoltConfig } from "./bolt";
-export { SCHEMA_VERSION, TS_PREFIX, twinOf, withTwins, buildSchemaDocument, NODE_LABELS, REL_TYPES, MARKER_LABELS } from "./schema";
+export { SCHEMA_VERSION, TS_PREFIX, buildSchemaDocument, NODE_LABELS, REL_TYPES, MARKER_LABELS } from "./schema";
 export type { SchemaDocument } from "./schema";
 export type { GraphRows, NodeRow, EdgeRow } from "./rows";
diff --git a/src/build/neo4j/project.ts b/src/build/neo4j/project.ts
index 3ebe77a..2c1fb0f 100644
--- a/src/build/neo4j/project.ts
+++ b/src/build/neo4j/project.ts
@@ -11,7 +11,7 @@
  */
 
 import type { V2Application, V2BodyNode, V2Callable, V2External, V2Field, V2Module, V2Node, V2Root, V2Type } from "../../schema/v2";
-import { SCHEMA_VERSION, withTwins } from "./schema";
+import { SCHEMA_VERSION } from "./schema";
 import { type GraphRows, type NodeRef, type Props, RowBuilder, prune } from "./rows";
 
 /** The shared MERGE label + key every can://-id-keyed node is addressed by. */
@@ -24,28 +24,28 @@ function fq(callableId: string, localKey: string): string {
 }
 
 const KIND_LABEL: Record<string, string> = {
-  module: "Module",
-  class: "Class",
-  interface: "Interface",
-  enum: "Enum",
-  type_alias: "TypeAlias",
-  namespace: "Namespace",
-  field: "Field",
-  external: "External",
-  function: "Callable",
-  method: "Callable",
-  constructor: "Callable",
-  getter: "Callable",
-  setter: "Callable",
-  arrow: "Callable",
-  function_expression: "Callable",
+  module: "TSModule",
+  class: "TSClass",
+  interface: "TSInterface",
+  enum: "TSEnum",
+  type_alias: "TSTypeAlias",
+  namespace: "TSNamespace",
+  field: "TSField",
+  external: "TSExternal",
+  function: "TSCallable",
+  method: "TSCallable",
+  constructor: "TSCallable",
+  getter: "TSCallable",
+  setter: "TSCallable",
+  arrow: "TSCallable",
+  function_expression: "TSCallable",
 };
 
 export function project(app: V2Application, _appName?: string): GraphRows {
-  const b = new RowBuilder(withTwins);
+  const b = new RowBuilder();
   const root: V2Root = app.application;
 
-  const appRef = b.node(["Application"], "id", root.id, prune({
+  const appRef = b.node(["Application", "TSApplication"], "id", root.id, prune({
     id: root.id,
     schema_version: SCHEMA_VERSION,
     language: app.language,
@@ -61,18 +61,18 @@ export function project(app: V2Application, _appName?: string): GraphRows {
 
   for (const mod of Object.values(root.symbol_table)) {
     const fileKey = moduleKeyOf(mod);
-    const modRef = b.node([CAN, "Module"], "id", mod.id, moduleProps(mod, fileKey));
-    b.edge("HAS_MODULE", appRef, modRef);
+    const modRef = b.node([CAN, "TSModule"], "id", mod.id, moduleProps(mod, fileKey));
+    b.edge("TS_HAS_MODULE", appRef, modRef);
     projectScope(b, mod, modRef, fileKey);
   }
 
   // External library targets (shared nodes — no _module).
   for (const ext of Object.values((root.external_symbols ?? {}) as Record<string, V2External>)) {
-    b.node([CAN, "External"], "id", ext.id, prune({ id: ext.id, kind: "external", name: ext.name, module: ext.module }));
+    b.node([CAN, "TSExternal"], "id", ext.id, prune({ id: ext.id, kind: "external", name: ext.name, module: ext.module }));
   }
   // First-party anonymous callbacks (edge endpoints the tree never names).
   for (const sc of Object.values((root.synthesized_callables ?? {}) as Record<string, V2Node>)) {
-    b.node([CAN, "AnonymousCallable"], "id", sc.id, prune({
+    b.node([CAN, "TSAnonymousCallable"], "id", sc.id, prune({
       id: sc.id, kind: "callable", name: str(sc.name), path: str(sc.path),
       start_line: spanLine(sc, "start"), start_column: spanCol(sc, "start"),
       _module: str(sc.path),
@@ -80,9 +80,9 @@ export function project(app: V2Application, _appName?: string): GraphRows {
   }
 
   // Overlay edges (application scope): the call graph + interprocedural param flow.
-  for (const e of root.call_graph) b.edge("CALLS", ref(e.src), ref(e.dst), prune({ weight: e.weight, prov: e.prov }));
-  for (const e of root.param_in) b.edge("PARAM_IN", ref(idOf(e.src)), ref(idOf(e.dst)), prune({ var: e.var ?? null }));
-  for (const e of root.param_out) b.edge("PARAM_OUT", ref(idOf(e.src)), ref(idOf(e.dst)), prune({ var: e.var ?? null }));
+  for (const e of root.call_graph) b.edge("TS_CALLS", ref(e.src), ref(e.dst), prune({ weight: e.weight, prov: e.prov }));
+  for (const e of root.param_in) b.edge("TS_PARAM_IN", ref(idOf(e.src)), ref(idOf(e.dst)), prune({ var: e.var ?? null }));
+  for (const e of root.param_out) b.edge("TS_PARAM_OUT", ref(idOf(e.src)), ref(idOf(e.dst)), prune({ var: e.var ?? null }));
 
   return b.finish();
 }
@@ -94,58 +94,58 @@ export function project(app: V2Application, _appName?: string): GraphRows {
 /** Walk a scope's child maps (module OR namespace: types + functions + fields). */
 function projectScope(b: RowBuilder, scope: V2Module | V2Type, parent: NodeRef, fileKey: string): void {
   for (const t of Object.values(scope.types ?? {})) projectType(b, t, parent, fileKey);
-  for (const c of Object.values(scope.functions ?? {})) projectCallable(b, c, parent, "DECLARES", fileKey);
+  for (const c of Object.values(scope.functions ?? {})) projectCallable(b, c, parent, "TS_DECLARES", fileKey);
   for (const f of Object.values(scope.fields ?? {})) projectField(b, f, parent, fileKey);
 }
 
 function projectType(b: RowBuilder, t: V2Type, parent: NodeRef, fileKey: string): void {
-  const label = KIND_LABEL[t.kind] ?? "Class";
+  const label = KIND_LABEL[t.kind] ?? "TSClass";
   const node = b.node([CAN, label], "id", t.id, typeProps(t, fileKey));
-  b.edge("DECLARES", parent, node);
+  b.edge("TS_DECLARES", parent, node);
   // Inheritance overlay — resolved-only (emit.ts already dropped unresolved/external supertypes);
   // the deferred gate is defense-in-depth against a resolved id that never materialized as a node.
-  for (const eid of t.extends_ids ?? []) b.edgeToSymbol("EXTENDS", node, eid);
-  for (const iid of t.implements_ids ?? []) b.edgeToSymbol("IMPLEMENTS", node, iid);
+  for (const eid of t.extends_ids ?? []) b.edgeToSymbol("TS_EXTENDS", node, eid);
+  for (const iid of t.implements_ids ?? []) b.edgeToSymbol("TS_IMPLEMENTS", node, iid);
   if (t.kind === "namespace") {
     projectScope(b, t, node, fileKey); // a namespace nests types/functions/fields
     return;
   }
-  for (const c of Object.values(t.callables ?? {})) projectCallable(b, c, node, "HAS_METHOD", fileKey);
+  for (const c of Object.values(t.callables ?? {})) projectCallable(b, c, node, "TS_HAS_METHOD", fileKey);
   for (const f of Object.values(t.fields ?? {})) projectField(b, f, node, fileKey);
 }
 
 function projectCallable(b: RowBuilder, c: V2Callable, owner: NodeRef, ownerRel: string, fileKey: string): void {
-  const node = b.node([CAN, "Callable"], "id", c.id, callableProps(c, fileKey));
+  const node = b.node([CAN, "TSCallable"], "id", c.id, callableProps(c, fileKey));
   b.edge(ownerRel, owner, node);
 
   // Body nodes (L1: call sites; L3+: statements + synthetic vertices) + their overlays.
   for (const [localKey, bn] of Object.entries(c.body ?? {})) {
     const bid = fq(c.id, localKey);
-    const bref = b.node([CAN, "BodyNode"], "id", bid, bodyProps(bn, bid, fileKey));
-    b.edge("HAS_BODY_NODE", node, bref);
-    if (typeof bn.callee === "string") b.edge("RESOLVES_TO", bref, ref(bn.callee));
+    const bref = b.node([CAN, "TSBodyNode"], "id", bid, bodyProps(bn, bid, fileKey));
+    b.edge("TS_HAS_BODY_NODE", node, bref);
+    if (typeof bn.callee === "string") b.edge("TS_RESOLVES_TO", bref, ref(bn.callee));
   }
   // kind-discriminated: a conditional's true/false pair between one endpoint pair must stay
   // two relationships, not one MERGE (issue #70).
-  for (const e of edges(c.cfg)) b.edge("CFG_NEXT", ref(fq(c.id, e.src)), ref(fq(c.id, e.dst)), prune({ kind: e.kind ?? null }), e.kind ?? "");
-  for (const e of edges(c.cdg)) b.edge("CDG", ref(fq(c.id, e.src)), ref(fq(c.id, e.dst)));
+  for (const e of edges(c.cfg)) b.edge("TS_CFG_NEXT", ref(fq(c.id, e.src)), ref(fq(c.id, e.dst)), prune({ kind: e.kind ?? null }), e.kind ?? "");
+  for (const e of edges(c.cdg)) b.edge("TS_CDG", ref(fq(c.id, e.src)), ref(fq(c.id, e.dst)));
   // (var, prov)-discriminated: the DDG legitimately carries several edges between one statement
   // pair (one per variable, and the prov split) — a plain endpoint-pair MERGE collapses them and
   // silently drops dependences (issue #70).
   for (const e of edges(c.ddg))
-    b.edge("DDG", ref(fq(c.id, e.src)), ref(fq(c.id, e.dst)), prune({ var: e.var ?? null, prov: e.prov ?? null }), `${e.var ?? ""}|${(e.prov ?? []).join(",")}`);
-  for (const e of edges(c.summary)) b.edge("SUMMARY", ref(fq(c.id, e.src)), ref(fq(c.id, e.dst)), prune({ var: e.var ?? null }));
+    b.edge("TS_DDG", ref(fq(c.id, e.src)), ref(fq(c.id, e.dst)), prune({ var: e.var ?? null, prov: e.prov ?? null }), `${e.var ?? ""}|${(e.prov ?? []).join(",")}`);
+  for (const e of edges(c.summary)) b.edge("TS_SUMMARY", ref(fq(c.id, e.src)), ref(fq(c.id, e.dst)), prune({ var: e.var ?? null }));
 
   // Nested callables (closures) + local classes.
-  for (const cc of Object.values(c.callables ?? {})) projectCallable(b, cc, node, "DECLARES", fileKey);
+  for (const cc of Object.values(c.callables ?? {})) projectCallable(b, cc, node, "TS_DECLARES", fileKey);
   for (const t of Object.values(c.types ?? {})) projectType(b, t, node, fileKey);
 }
 
 function projectField(b: RowBuilder, f: V2Field, owner: NodeRef, fileKey: string): void {
-  const node = b.node([CAN, "Field"], "id", f.id, prune({
+  const node = b.node([CAN, "TSField"], "id", f.id, prune({
     id: f.id, kind: "field", name: str(f.name), type: str((f as V2Node).type), ...span(f), _module: fileKey,
   }));
-  b.edge("HAS_FIELD", owner, node);
+  b.edge("TS_HAS_FIELD", owner, node);
 }
 
 // ----------------------------------------------------------------------------------------------
diff --git a/src/build/neo4j/rows.ts b/src/build/neo4j/rows.ts
index fe4c5e2..437cd4f 100644
--- a/src/build/neo4j/rows.ts
+++ b/src/build/neo4j/rows.ts
@@ -16,7 +16,7 @@ const CAN_NODE = "CanNode";
 
 /** How an edge addresses one of its endpoints: the label + key property to MATCH on, and value. */
 export interface NodeRef {
-  label: string; // the label carrying the uniqueness constraint (e.g. "Symbol", "Module")
+  label: string; // the label carrying the uniqueness constraint ("Application" | "CanNode")
   keyProp: string; // "signature" | "file_key" | "name" | "qualified_name" | "id"
   value: string;
 }
@@ -68,19 +68,12 @@ export class RowBuilder {
   private readonly deferred: EdgeRow[] = []; // edges gated against node existence at finish()
   private readonly keys = new Set<string>(); // every node value seen, for resolved-gating
 
-  /**
-   * @param expand optional label-set expander applied to every node's labels (the schema layer
-   * injects its twin-label policy here; rows.ts itself stays schema-agnostic). Must keep the
-   * merge label at index 0.
-   */
-  constructor(private readonly expand: (labels: string[]) => string[] = (l) => l) {}
-
   /**
    * Upsert a node. Re-seeing the same (mergeLabel, value) merges props (last write wins) and
-   * unions labels — the in-memory analog of `MERGE (n:Label {key}) SET n += props`.
+   * unions labels — the in-memory analog of `MERGE (n:Label {key}) SET n += props`. `labels[0]`
+   * must be the merge label ("Application" | "CanNode").
    */
   node(labels: string[], keyProp: string, value: string, props: Props): NodeRef {
-    labels = this.expand(labels);
     const id = `${labels[0]}\0${value}`;
     const existing = this.nodes.get(id);
     if (existing) {
diff --git a/src/build/neo4j/schema.ts b/src/build/neo4j/schema.ts
index d57c8ae..84fcc99 100644
--- a/src/build/neo4j/schema.ts
+++ b/src/build/neo4j/schema.ts
@@ -10,7 +10,11 @@
  * node keyed on its `can://` id under the shared MERGE label `CanNode` (one uniqueness constraint,
  * uniform edge endpoints), carrying a specific kind label; containment renders as HAS_x / DECLARES
  * edges and every typed overlay (call_graph, cfg/cdg/ddg/summary, param_in/param_out) as a typed
- * relationship. TypeScript uses UNPREFIXED relationship names.
+ * relationship. At 2.0.0 (issue #66) the vocabulary is namespaced for TypeScript: every specific
+ * node label is `TS`-prefixed (`TSModule`, `TSCallable`, ...; the shared MERGE labels `CanNode` and
+ * `Application` stay bare) and every relationship type is `TS_`-prefixed (`TS_CALLS`, ...) — this
+ * lets a shared multi-language database attribute TS-origin graph elements (epic #64) without a
+ * transitional dual-labeling step.
  *
  * SCHEMA_VERSION: MAJOR on a breaking change (renamed/removed label, relationship or key), MINOR
  * on additive. v2 is a MAJOR bump from v1 (keys moved signature→can:// id; labels reshaped).
@@ -38,35 +42,9 @@ export interface RelType {
 /** Labels layered onto a node in addition to its primary/specific label. */
 export const MARKER_LABELS = [] as const;
 
-/**
- * Language-namespace twins (transient dual-labeling, issue #65): every specific and marker label is
- * also stamped as `TS<Label>` so a shared multi-language database can attribute TS nodes (epic #64).
- * The shared MERGE labels (`Symbol`, `CanNode`) deliberately have NO twin — MERGE targets, keys and
- * constraints are unchanged. This dual-label state is transient; the vocabulary is finalized later.
- */
+/** The namespace prefix every specific node label and relationship type carries at 2.0.0 (#66). */
 export const TS_PREFIX = "TS";
 
-/** The TS-prefixed twin of a specific or marker label. */
-export const twinOf = (label: string): string => `${TS_PREFIX}${label}`;
-
-/** Shared merge labels never get a twin — they carry the constraint; node identity is unchanged. */
-const UNTWINNED = new Set(["Symbol", "CanNode"]);
-
-/**
- * Expand a projection label set with its twins: order preserved, shared merge labels skipped,
- * idempotent. Any label already starting with `TS` is treated as a twin and never re-prefixed — so
- * no bare label may legitimately begin with `TS`.
- */
-export function withTwins(labels: string[]): string[] {
-  const out = [...labels];
-  for (const l of labels) {
-    if (UNTWINNED.has(l) || l.startsWith(TS_PREFIX)) continue;
-    const t = twinOf(l);
-    if (!out.includes(t)) out.push(t);
-  }
-  return out;
-}
-
 /** The shared MERGE label for every can://-id-keyed node (one constraint; uniform edge endpoints). */
 const CAN = "CanNode";
 const SPAN = { start_line: "integer", end_line: "integer" } as const;
@@ -75,7 +53,7 @@ const COMMON = { id: "string", kind: "string", _module: "string" } as const;
 
 export const NODE_LABELS: NodeLabel[] = [
   {
-    label: "Application",
+    label: "TSApplication",
     mergeLabel: "Application",
     key: "id",
     properties: {
@@ -87,13 +65,13 @@ export const NODE_LABELS: NodeLabel[] = [
     },
   },
   {
-    label: "Module",
+    label: "TSModule",
     mergeLabel: CAN,
     key: "id",
     properties: { ...COMMON, name: "string", is_tsx: "boolean", is_declaration_file: "boolean", content_hash: "string", ...SPAN },
   },
   {
-    label: "Class",
+    label: "TSClass",
     mergeLabel: CAN,
     key: "id",
     properties: {
@@ -102,31 +80,31 @@ export const NODE_LABELS: NodeLabel[] = [
     },
   },
   {
-    label: "Interface",
+    label: "TSInterface",
     mergeLabel: CAN,
     key: "id",
     properties: { ...COMMON, signature: "string", name: "string", base_classes: "string[]", is_exported: "boolean", is_ambient: "boolean", ...SPAN },
   },
   {
-    label: "Enum",
+    label: "TSEnum",
     mergeLabel: CAN,
     key: "id",
     properties: { ...COMMON, signature: "string", name: "string", is_const: "boolean", is_exported: "boolean", is_ambient: "boolean", ...SPAN },
   },
   {
-    label: "TypeAlias",
+    label: "TSTypeAlias",
     mergeLabel: CAN,
     key: "id",
     properties: { ...COMMON, signature: "string", name: "string", aliased_type: "string", is_exported: "boolean", is_ambient: "boolean", ...SPAN },
   },
   {
-    label: "Namespace",
+    label: "TSNamespace",
     mergeLabel: CAN,
     key: "id",
     properties: { ...COMMON, signature: "string", name: "string", is_exported: "boolean", is_ambient: "boolean", ...SPAN },
   },
   {
-    label: "Callable",
+    label: "TSCallable",
     mergeLabel: CAN,
     key: "id",
     properties: {
@@ -136,18 +114,18 @@ export const NODE_LABELS: NodeLabel[] = [
       ...SPAN,
     },
   },
-  { label: "Field", mergeLabel: CAN, key: "id", properties: { ...COMMON, name: "string", type: "string", ...SPAN } },
+  { label: "TSField", mergeLabel: CAN, key: "id", properties: { ...COMMON, name: "string", type: "string", ...SPAN } },
   {
     // A statement / synthetic vertex inside a callable body (kind = statement|call|entry|exit|
     // formal_in|formal_out|actual_in|actual_out). `callee` on call nodes; `of`/`parent` on synthetics.
-    label: "BodyNode",
+    label: "TSBodyNode",
     mergeLabel: CAN,
     key: "id",
     properties: { ...COMMON, of: "string", parent: "string", callee: "string", ...SPAN },
   },
-  { label: "External", mergeLabel: CAN, key: "id", properties: { ...COMMON, name: "string", module: "string" } },
+  { label: "TSExternal", mergeLabel: CAN, key: "id", properties: { ...COMMON, name: "string", module: "string" } },
   {
-    label: "AnonymousCallable",
+    label: "TSAnonymousCallable",
     mergeLabel: CAN,
     key: "id",
     properties: { ...COMMON, name: "string", path: "string", start_line: "integer", start_column: "integer" },
@@ -155,39 +133,39 @@ export const NODE_LABELS: NodeLabel[] = [
 ];
 
 export const REL_TYPES: RelType[] = [
-  { type: "HAS_MODULE", from: ["Application"], to: ["Module"], properties: {} },
+  { type: "TS_HAS_MODULE", from: ["TSApplication"], to: ["TSModule"], properties: {} },
   {
-    type: "DECLARES",
-    from: ["Module", "Namespace", "Callable"],
-    to: ["Class", "Interface", "Enum", "TypeAlias", "Namespace", "Callable"],
+    type: "TS_DECLARES",
+    from: ["TSModule", "TSNamespace", "TSCallable"],
+    to: ["TSClass", "TSInterface", "TSEnum", "TSTypeAlias", "TSNamespace", "TSCallable"],
     properties: {},
   },
-  { type: "HAS_METHOD", from: ["Class", "Interface"], to: ["Callable"], properties: {} },
-  { type: "HAS_FIELD", from: ["Module", "Class", "Interface", "Enum", "Namespace"], to: ["Field"], properties: {} },
-  { type: "HAS_BODY_NODE", from: ["Callable", "AnonymousCallable"], to: ["BodyNode"], properties: {} },
-  { type: "RESOLVES_TO", from: ["BodyNode"], to: ["Callable", "External", "AnonymousCallable"], properties: {} },
+  { type: "TS_HAS_METHOD", from: ["TSClass", "TSInterface"], to: ["TSCallable"], properties: {} },
+  { type: "TS_HAS_FIELD", from: ["TSModule", "TSClass", "TSInterface", "TSEnum", "TSNamespace"], to: ["TSField"], properties: {} },
+  { type: "TS_HAS_BODY_NODE", from: ["TSCallable", "TSAnonymousCallable"], to: ["TSBodyNode"], properties: {} },
+  { type: "TS_RESOLVES_TO", from: ["TSBodyNode"], to: ["TSCallable", "TSExternal", "TSAnonymousCallable"], properties: {} },
   {
-    type: "CALLS",
-    from: ["Callable", "AnonymousCallable"],
-    to: ["Callable", "External", "AnonymousCallable"],
+    type: "TS_CALLS",
+    from: ["TSCallable", "TSAnonymousCallable"],
+    to: ["TSCallable", "TSExternal", "TSAnonymousCallable"],
     properties: { weight: "integer", prov: "string[]" },
   },
-  // `_k` is the relationship-identity discriminant (internal): CFG_NEXT merges per `kind`
-  // (a conditional's true/false pair), DDG per `(var, prov)` (one dependence per variable, plus
+  // `_k` is the relationship-identity discriminant (internal): TS_CFG_NEXT merges per `kind`
+  // (a conditional's true/false pair), TS_DDG per `(var, prov)` (one dependence per variable, plus
   // the prov split) — a plain endpoint-pair MERGE would collapse legitimately-distinct edges
   // (issue #70).
-  { type: "CFG_NEXT", from: ["BodyNode"], to: ["BodyNode"], properties: { kind: "string", _k: "string" } },
-  { type: "CDG", from: ["BodyNode"], to: ["BodyNode"], properties: {} },
-  { type: "DDG", from: ["BodyNode"], to: ["BodyNode"], properties: { var: "string", prov: "string[]", _k: "string" } },
-  { type: "SUMMARY", from: ["BodyNode"], to: ["BodyNode"], properties: { var: "string" } },
-  { type: "PARAM_IN", from: ["BodyNode"], to: ["BodyNode"], properties: { var: "string" } },
-  { type: "PARAM_OUT", from: ["BodyNode"], to: ["BodyNode"], properties: { var: "string" } },
+  { type: "TS_CFG_NEXT", from: ["TSBodyNode"], to: ["TSBodyNode"], properties: { kind: "string", _k: "string" } },
+  { type: "TS_CDG", from: ["TSBodyNode"], to: ["TSBodyNode"], properties: {} },
+  { type: "TS_DDG", from: ["TSBodyNode"], to: ["TSBodyNode"], properties: { var: "string", prov: "string[]", _k: "string" } },
+  { type: "TS_SUMMARY", from: ["TSBodyNode"], to: ["TSBodyNode"], properties: { var: "string" } },
+  { type: "TS_PARAM_IN", from: ["TSBodyNode"], to: ["TSBodyNode"], properties: { var: "string" } },
+  { type: "TS_PARAM_OUT", from: ["TSBodyNode"], to: ["TSBodyNode"], properties: { var: "string" } },
   // Inheritance, projected from the `extends_ids`/`implements_ids` node props (schema/v2/emit.ts) —
-  // resolved-only: an unresolved (external/library) supertype never reaches here. A `to` of `Class`
+  // resolved-only: an unresolved (external/library) supertype never reaches here. A `to` of `TSClass`
   // covers TS's `implements SomeClass` (structural, not just interfaces); an interface may itself
-  // `extends` a class's instance type, hence `EXTENDS` also allows an `Interface` source.
-  { type: "EXTENDS", from: ["Class", "Interface"], to: ["Class", "Interface"], properties: {} },
-  { type: "IMPLEMENTS", from: ["Class"], to: ["Interface", "Class"], properties: {} },
+  // `extends` a class's instance type, hence `TS_EXTENDS` also allows a `TSInterface` source.
+  { type: "TS_EXTENDS", from: ["TSClass", "TSInterface"], to: ["TSClass", "TSInterface"], properties: {} },
+  { type: "TS_IMPLEMENTS", from: ["TSClass"], to: ["TSInterface", "TSClass"], properties: {} },
 ];
 
 // ----------------------------------------------------------------------------------------------
@@ -214,7 +192,7 @@ export const CONSTRAINTS: readonly string[] = uniquenessConstraints();
 
 /** Curated performance indexes (not 1:1 with labels, so declared explicitly). */
 export const INDEXES: readonly string[] = [
-  "CREATE INDEX callable_name IF NOT EXISTS FOR (c:Callable) ON (c.name)",
+  "CREATE INDEX callable_name IF NOT EXISTS FOR (c:TSCallable) ON (c.name)",
   "CREATE INDEX cannode_kind IF NOT EXISTS FOR (n:CanNode) ON (n.kind)",
 ];
 
@@ -226,16 +204,6 @@ export interface SchemaDocument {
   relationship_types: RelType[];
   constraints: readonly string[];
   indexes: readonly string[];
-  /** Specific/marker label → its TS-prefixed twin (both are present on every emitted node). */
-  label_twins: Record<string, string>;
-}
-
-/** One twin per specific label + per marker label — derived from the catalogs, never drifts. */
-function labelTwins(): Record<string, string> {
-  const out: Record<string, string> = {};
-  for (const n of NODE_LABELS) out[n.label] = twinOf(n.label);
-  for (const m of MARKER_LABELS) out[m] = twinOf(m);
-  return out;
 }
 
 /** Build the full machine-readable schema document emitted by `--emit schema`. */
@@ -248,6 +216,5 @@ export function buildSchemaDocument(): SchemaDocument {
     relationship_types: REL_TYPES,
     constraints: CONSTRAINTS,
     indexes: INDEXES,
-    label_twins: labelTwins(),
   };
 }
diff --git a/test/external-resolution.test.ts b/test/external-resolution.test.ts
index c36463f..e8ed974 100644
--- a/test/external-resolution.test.ts
+++ b/test/external-resolution.test.ts
@@ -1,5 +1,5 @@
 /**
- * #53 — checker-known external/library calls resolve to `:External` phantoms instead of being
+ * #53 — checker-known external/library calls resolve to `:TSExternal` phantoms instead of being
  * dropped. `resolveCalleeSignature` (src/schema/signatures.ts) already asks the ts-morph checker
  * for the callee's declaration; before this fix it only kept the result when the declaration lived
  * in-project (gated by `allSignatures`), silently discarding anything the checker resolved into
diff --git a/test/neo4j-bolt.test.ts b/test/neo4j-bolt.test.ts
index 47ca0bf..9ac5559 100644
--- a/test/neo4j-bolt.test.ts
+++ b/test/neo4j-bolt.test.ts
@@ -100,7 +100,7 @@ containerSuite("neo4j bolt writer", () => {
       // merge label — Application is the only node kind that sits outside it).
       const canNode = await num("MATCH (s:CanNode) RETURN count(s)");
       const kinds = await num(
-        "MATCH (s:CanNode) WHERE s:Module OR s:Class OR s:Interface OR s:Enum OR s:TypeAlias OR s:Namespace OR s:Callable OR s:Field OR s:BodyNode OR s:External OR s:AnonymousCallable RETURN count(s)",
+        "MATCH (s:CanNode) WHERE s:TSModule OR s:TSClass OR s:TSInterface OR s:TSEnum OR s:TSTypeAlias OR s:TSNamespace OR s:TSCallable OR s:TSField OR s:TSBodyNode OR s:TSExternal OR s:TSAnonymousCallable RETURN count(s)",
       );
       expect(canNode).toBeGreaterThan(0);
       expect(kinds).toBe(canNode);
@@ -112,7 +112,7 @@ containerSuite("neo4j bolt writer", () => {
       // A known resolved call edge from the fixture (index.ts calls services.announce).
       expect(
         await num(
-          "MATCH (:Callable)-[:CALLS]->(t:Callable {name:$n}) RETURN count(*)",
+          "MATCH (:TSCallable)-[:TS_CALLS]->(t:TSCallable {name:$n}) RETURN count(*)",
           { n: "announce" },
         ),
       ).toBeGreaterThan(0);
@@ -144,7 +144,7 @@ containerSuite("neo4j bolt writer", () => {
       // The victim's nodes are gone.
       expect(await num("MATCH (n {_module:$m}) RETURN count(n)", { m: victim })).toBe(0);
 
-      // The surviving module-scoped graph matches the reduced projection. (Shared :External/:Package
+      // The surviving module-scoped graph matches the reduced projection. (Shared :TSExternal
       // nodes are MERGE-only and intentionally never pruned, so we compare only _module-tagged nodes.)
       const moduleScoped = rows.nodes.filter((n) => "_module" in n.props).length;
       expect(await num("MATCH (n) WHERE n._module IS NOT NULL RETURN count(n)")).toBe(moduleScoped);
diff --git a/test/neo4j-edge-identity.test.ts b/test/neo4j-edge-identity.test.ts
index 6525081..0909d31 100644
--- a/test/neo4j-edge-identity.test.ts
+++ b/test/neo4j-edge-identity.test.ts
@@ -11,32 +11,32 @@ import { RowBuilder } from "../src/build/neo4j/rows";
 
 function twoVarDdgRows() {
   const b = new RowBuilder();
-  const a = b.node(["CanNode", "BodyNode"], "id", "can://ts/app/f.ts/f()@1:0", {});
-  const c = b.node(["CanNode", "BodyNode"], "id", "can://ts/app/f.ts/f()@2:0", {});
-  b.edge("DDG", a, c, { var: "x", prov: ["reaching-defs"] }, "x|reaching-defs");
-  b.edge("DDG", a, c, { var: "y", prov: ["reaching-defs"] }, "y|reaching-defs");
-  b.edge("CDG", a, c); // undiscriminated control family stays a plain MERGE
+  const a = b.node(["CanNode", "TSBodyNode"], "id", "can://ts/app/f.ts/f()@1:0", {});
+  const c = b.node(["CanNode", "TSBodyNode"], "id", "can://ts/app/f.ts/f()@2:0", {});
+  b.edge("TS_DDG", a, c, { var: "x", prov: ["reaching-defs"] }, "x|reaching-defs");
+  b.edge("TS_DDG", a, c, { var: "y", prov: ["reaching-defs"] }, "y|reaching-defs");
+  b.edge("TS_CDG", a, c); // undiscriminated control family stays a plain MERGE
   return b.finish();
 }
 
 describe("edge identity discriminant (_k)", () => {
   test("per-var DDG edges between one endpoint pair both survive rendering", () => {
     const cypher = renderCypher(twoVarDdgRows(), "app");
-    expect(cypher).toContain("MERGE (a)-[r:DDG {_k: row.k}]->(b)");
+    expect(cypher).toContain("MERGE (a)-[r:TS_DDG {_k: row.k}]->(b)");
     expect(cypher).toContain("k: 'x|reaching-defs'");
     expect(cypher).toContain("k: 'y|reaching-defs'");
   });
 
   test("undiscriminated families keep the plain endpoint-pair MERGE", () => {
     const cypher = renderCypher(twoVarDdgRows(), "app");
-    expect(cypher).toContain("MERGE (a)-[r:CDG]->(b)");
-    expect(cypher).not.toContain("MERGE (a)-[r:CDG {_k");
+    expect(cypher).toContain("MERGE (a)-[r:TS_CDG]->(b)");
+    expect(cypher).not.toContain("MERGE (a)-[r:TS_CDG {_k");
   });
 
   test("row model carries the discriminant only when set", () => {
     const rows = twoVarDdgRows();
-    const ddg = rows.edges.filter((e) => e.type === "DDG");
-    const cdg = rows.edges.filter((e) => e.type === "CDG");
+    const ddg = rows.edges.filter((e) => e.type === "TS_DDG");
+    const cdg = rows.edges.filter((e) => e.type === "TS_CDG");
     expect(ddg.map((e) => e.key).sort()).toEqual(["x|reaching-defs", "y|reaching-defs"]);
     expect(cdg[0].key).toBeUndefined();
     // distinct identity per (type, endpoints, key): nothing deduplicates the pair
diff --git a/test/neo4j-schema.test.ts b/test/neo4j-schema.test.ts
index 9c8079b..9192a76 100644
--- a/test/neo4j-schema.test.ts
+++ b/test/neo4j-schema.test.ts
@@ -16,8 +16,6 @@ import {
   REL_TYPES,
   buildSchemaDocument,
   project,
-  twinOf,
-  withTwins,
 } from "../src/build/neo4j";
 import { analyze } from "../src/core";
 import type { AnalysisOptions } from "../src/options";
@@ -46,17 +44,13 @@ const byLabel = new Map(NODE_LABELS.map((n) => [n.label, n]));
 const mergeOf = new Map(NODE_LABELS.map((n) => [n.label, n.mergeLabel]));
 const relByType = new Map(REL_TYPES.map((r) => [r.type, r]));
 const markers = new Set<string>(MARKER_LABELS);
-const twins = new Set<string>([
-  ...NODE_LABELS.map((n) => twinOf(n.label)),
-  ...MARKER_LABELS.map((m) => twinOf(m)),
-]);
 const mergeLabelsFor = (specifics: string[]) => new Set(specifics.map((s) => mergeOf.get(s)));
 
-/** The specific (schema) label for a node row: the non-merge, non-marker, non-twin label
- * (`Application` has only its own label; every `CanNode` carries exactly one specific kind label). */
+/** The specific (schema) label for a node row: the non-merge, non-marker label (`TSApplication`
+ * carries `Application` as its merge label; every `CanNode` carries exactly one specific kind label). */
 function specificLabel(labels: string[]): string {
   const merge = labels[0];
-  return labels.find((l) => l !== merge && !markers.has(l) && !twins.has(l)) ?? merge;
+  return labels.find((l) => l !== merge && !markers.has(l)) ?? merge;
 }
 
 const rows = await fixtureRows();
@@ -71,7 +65,7 @@ describe("neo4j schema conformance", () => {
       expect(node.labels[0]).toBe(decl!.mergeLabel);
 
       for (const label of node.labels) {
-        const ok = label === decl!.mergeLabel || label === specific || markers.has(label) || twins.has(label);
+        const ok = label === decl!.mergeLabel || label === specific || markers.has(label);
         expect(ok, `unexpected label '${label}' on ${specific}`).toBe(true);
       }
       for (const key of Object.keys(node.props)) {
@@ -107,15 +101,14 @@ describe("neo4j schema conformance", () => {
     }
   });
 
-  test("every node carries exactly the TS twins of its base labels (transient dual-labeling)", () => {
+  test("2.0.0 emits only TS-prefixed specific labels and TS_ rel types (#66)", () => {
     for (const node of rows.nodes) {
-      const base = node.labels.filter((l) => !twins.has(l));
-      expect(new Set(node.labels), `bad twin set on ${node.labels.join(":")} ${node.value}`).toEqual(
-        new Set(withTwins(base)),
-      );
-      // the shared merge label (`CanNode` / `Application`) stays bare at index 0.
-      expect(twins.has(node.labels[0]), `merge label must stay bare: ${node.labels[0]}`).toBe(false);
+      for (const l of node.labels) {
+        const ok = l === "CanNode" || l === "Application" || l.startsWith("TS");
+        expect(ok, `bare label leaked: ${l}`).toBe(true);
+      }
     }
+    for (const edge of rows.edges) expect(edge.type.startsWith("TS_"), `bare rel leaked: ${edge.type}`).toBe(true);
   });
 });
 
@@ -139,8 +132,8 @@ describe(":Application node carries analyzer identity (issue #43)", () => {
 
 describe("neo4j inheritance edges (issue #33)", () => {
   test("EXTENDS and IMPLEMENTS are declared in the schema catalog", () => {
-    expect(relByType.has("EXTENDS")).toBe(true);
-    expect(relByType.has("IMPLEMENTS")).toBe(true);
+    expect(relByType.has("TS_EXTENDS")).toBe(true);
+    expect(relByType.has("TS_IMPLEMENTS")).toBe(true);
   });
 
   function nodeBySignature(signature: string) {
@@ -157,8 +150,8 @@ describe("neo4j inheritance edges (issue #33)", () => {
     expect(shape, "Shape node").toBeDefined();
     expect(labeled, "Labeled node").toBeDefined();
 
-    const ext = rows.edges.filter((e) => e.type === "EXTENDS");
-    const impl = rows.edges.filter((e) => e.type === "IMPLEMENTS");
+    const ext = rows.edges.filter((e) => e.type === "TS_EXTENDS");
+    const impl = rows.edges.filter((e) => e.type === "TS_IMPLEMENTS");
     expect(ext.length).toBeGreaterThan(0);
     expect(impl.length).toBeGreaterThan(0);
 
@@ -178,10 +171,10 @@ describe("neo4j inheritance edges (issue #33)", () => {
     const shape = nodeBySignature("src/hierarchy.Shape");
     expect(coloredShape, "ColoredShape node").toBeDefined();
     expect(shape, "Shape node").toBeDefined();
-    expect(specificLabel(coloredShape!.labels)).toBe("Interface");
-    expect(specificLabel(shape!.labels)).toBe("Interface");
+    expect(specificLabel(coloredShape!.labels)).toBe("TSInterface");
+    expect(specificLabel(shape!.labels)).toBe("TSInterface");
 
-    const ext = rows.edges.filter((e) => e.type === "EXTENDS");
+    const ext = rows.edges.filter((e) => e.type === "TS_EXTENDS");
     expect(ext.some((e) => e.from.value === coloredShape!.value && e.to.value === shape!.value)).toBe(true);
 
     const nodeValues = new Set(rows.nodes.map((n) => n.value));
diff --git a/test/neo4j-twins.test.ts b/test/neo4j-twins.test.ts
deleted file mode 100644
index 0b59a5e..0000000
--- a/test/neo4j-twins.test.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-/**
- * Twin-label vocabulary (transient dual-labeling on graph schema 2.0.0, issue #65): every specific
- * and marker label has a TS-prefixed twin; the shared merge labels (`Symbol`, `CanNode`)
- * deliberately have none (epic #64). The v2 catalog merges on `CanNode`, so it is the merge label
- * that must stay bare here.
- */
-import { describe, expect, test } from "bun:test";
-import {
-  MARKER_LABELS,
-  NODE_LABELS,
-  SCHEMA_VERSION,
-  TS_PREFIX,
-  buildSchemaDocument,
-  twinOf,
-  withTwins,
-} from "../src/build/neo4j";
-
-describe("TS twin-label vocabulary", () => {
-  test("twinOf prefixes with TS", () => {
-    expect(TS_PREFIX).toBe("TS");
-    expect(twinOf("Callable")).toBe("TSCallable");
-  });
-
-  test("withTwins appends a twin per label, keeps order, and skips shared merge labels", () => {
-    expect(withTwins(["Module"])).toEqual(["Module", "TSModule"]);
-    // both shared merge labels are skipped (v2 merges on CanNode)
-    expect(withTwins(["CanNode", "Callable"])).toEqual(["CanNode", "Callable", "TSCallable"]);
-    expect(withTwins(["Symbol", "Class"])).toEqual(["Symbol", "Class", "TSClass"]);
-    // idempotent: an already-expanded set gains nothing
-    expect(withTwins(["Module", "TSModule"])).toEqual(["Module", "TSModule"]);
-  });
-
-  test("schema version is 2.0.0 (v2 catalog)", () => {
-    expect(SCHEMA_VERSION).toBe("2.0.0");
-  });
-
-  test("schema document maps every specific + marker label to its twin", () => {
-    const doc = buildSchemaDocument();
-    for (const n of NODE_LABELS) expect(doc.label_twins[n.label]).toBe(twinOf(n.label));
-    for (const m of MARKER_LABELS) expect(doc.label_twins[m]).toBe(twinOf(m));
-    // shared merge labels are never specific/marker labels, so they map to nothing
-    expect(doc.label_twins["CanNode"]).toBeUndefined();
-    expect(doc.label_twins["Symbol"]).toBeUndefined();
-    // 12 node labels + 0 markers (none currently) = 12 twins
-    expect(Object.keys(doc.label_twins).length).toBe(12);
-    expect(Object.keys(doc.label_twins).length).toBe(NODE_LABELS.length + MARKER_LABELS.length);
-  });
-});
diff --git a/test/schema-v2.test.ts b/test/schema-v2.test.ts
index c9f533a..4924e5b 100644
--- a/test/schema-v2.test.ts
+++ b/test/schema-v2.test.ts
@@ -727,13 +727,13 @@ describe("neo4j ↔ json count parity — full depth (issue #27)", () => {
 
   test("typed overlay relationships match their JSON edge-list length 1:1", () => {
     const callables = allCallables(monoApp4.application);
-    expect(relCount(monoRows, "CALLS")).toBe(monoApp4.application.call_graph.length);
-    expect(relCount(monoRows, "PARAM_IN")).toBe(monoApp4.application.param_in.length);
-    expect(relCount(monoRows, "PARAM_OUT")).toBe(monoApp4.application.param_out.length);
-    expect(relCount(monoRows, "CFG_NEXT")).toBe(callables.reduce((n, c) => n + (c.cfg?.length ?? 0), 0));
-    expect(relCount(monoRows, "CDG")).toBe(callables.reduce((n, c) => n + (c.cdg?.length ?? 0), 0));
-    expect(relCount(monoRows, "DDG")).toBe(callables.reduce((n, c) => n + (c.ddg?.length ?? 0), 0));
-    expect(relCount(monoRows, "SUMMARY")).toBe(callables.reduce((n, c) => n + (c.summary?.length ?? 0), 0));
+    expect(relCount(monoRows, "TS_CALLS")).toBe(monoApp4.application.call_graph.length);
+    expect(relCount(monoRows, "TS_PARAM_IN")).toBe(monoApp4.application.param_in.length);
+    expect(relCount(monoRows, "TS_PARAM_OUT")).toBe(monoApp4.application.param_out.length);
+    expect(relCount(monoRows, "TS_CFG_NEXT")).toBe(callables.reduce((n, c) => n + (c.cfg?.length ?? 0), 0));
+    expect(relCount(monoRows, "TS_CDG")).toBe(callables.reduce((n, c) => n + (c.cdg?.length ?? 0), 0));
+    expect(relCount(monoRows, "TS_DDG")).toBe(callables.reduce((n, c) => n + (c.ddg?.length ?? 0), 0));
+    expect(relCount(monoRows, "TS_SUMMARY")).toBe(callables.reduce((n, c) => n + (c.summary?.length ?? 0), 0));
   });
 
   test("containment relationships (HAS_*/DECLARES) match tree cardinality, not a JSON edge-list", () => {
@@ -745,7 +745,7 @@ describe("neo4j ↔ json count parity — full depth (issue #27)", () => {
     // `extends_ids`/`implements_ids` props respectively — but they are not containment either, so
     // they're deliberately excluded from this invariant too; see the dedicated tests below and the
     // exhaustive edge-accounting test that folds every relationship family back into one total.)
-    const containment = ["HAS_MODULE", "DECLARES", "HAS_METHOD", "HAS_FIELD", "HAS_BODY_NODE"];
+    const containment = ["TS_HAS_MODULE", "TS_DECLARES", "TS_HAS_METHOD", "TS_HAS_FIELD", "TS_HAS_BODY_NODE"];
     const containmentEdges = containment.reduce((n, t) => n + relCount(monoRows, t), 0);
     const externalCount = Object.keys(monoApp4.application.external_symbols ?? {}).length;
     const synthCount = Object.keys(monoApp4.application.synthesized_callables ?? {}).length;
@@ -760,8 +760,8 @@ describe("neo4j ↔ json count parity — full depth (issue #27)", () => {
     // kinds — guards against a vacuous 0 === 0 pass if the fixture ever loses its heritage.
     expect(extendsCount).toBeGreaterThan(0);
     expect(implementsCount).toBeGreaterThan(0);
-    expect(relCount(monoRows, "EXTENDS")).toBe(extendsCount);
-    expect(relCount(monoRows, "IMPLEMENTS")).toBe(implementsCount);
+    expect(relCount(monoRows, "TS_EXTENDS")).toBe(extendsCount);
+    expect(relCount(monoRows, "TS_IMPLEMENTS")).toBe(implementsCount);
   });
 
   test("every projected edge is accounted for: typed overlay + containment + RESOLVES_TO + EXTENDS/IMPLEMENTS sums to the total", () => {
@@ -770,19 +770,19 @@ describe("neo4j ↔ json count parity — full depth (issue #27)", () => {
     // project.ts ever grows a new relationship family without this test learning about it, the two
     // sides diverge and the gate fails, instead of silently passing on an incomplete accounting.
     const typedOverlay =
-      relCount(monoRows, "CALLS") +
-      relCount(monoRows, "PARAM_IN") +
-      relCount(monoRows, "PARAM_OUT") +
-      relCount(monoRows, "CFG_NEXT") +
-      relCount(monoRows, "CDG") +
-      relCount(monoRows, "DDG") +
-      relCount(monoRows, "SUMMARY");
-    const containment = ["HAS_MODULE", "DECLARES", "HAS_METHOD", "HAS_FIELD", "HAS_BODY_NODE"].reduce(
+      relCount(monoRows, "TS_CALLS") +
+      relCount(monoRows, "TS_PARAM_IN") +
+      relCount(monoRows, "TS_PARAM_OUT") +
+      relCount(monoRows, "TS_CFG_NEXT") +
+      relCount(monoRows, "TS_CDG") +
+      relCount(monoRows, "TS_DDG") +
+      relCount(monoRows, "TS_SUMMARY");
+    const containment = ["TS_HAS_MODULE", "TS_DECLARES", "TS_HAS_METHOD", "TS_HAS_FIELD", "TS_HAS_BODY_NODE"].reduce(
       (n, t) => n + relCount(monoRows, t),
       0,
     );
-    const resolvesTo = relCount(monoRows, "RESOLVES_TO");
-    const heritage = relCount(monoRows, "EXTENDS") + relCount(monoRows, "IMPLEMENTS");
+    const resolvesTo = relCount(monoRows, "TS_RESOLVES_TO");
+    const heritage = relCount(monoRows, "TS_EXTENDS") + relCount(monoRows, "TS_IMPLEMENTS");
     expect(resolvesTo).toBe(resolvesToCount(monoApp4));
     expect(typedOverlay + containment + resolvesTo + heritage).toBe(monoRows.edges.length);
   });
@@ -793,7 +793,7 @@ describe("neo4j ↔ json count parity — full depth (issue #27)", () => {
     // relationship per distinct (from, to, key) tuple. If any row lacked a key, or two parallel
     // rows shared one, MERGE would silently collapse them and row-level parity would never notice.
     // This pins the discriminant on the real L4 projection, not a synthetic fixture.
-    for (const type of ["DDG", "CFG_NEXT"] as const) {
+    for (const type of ["TS_DDG", "TS_CFG_NEXT"] as const) {
       const rows = monoRows.edges.filter((e) => e.type === type);
       expect(rows.length).toBeGreaterThan(0);
       expect(rows.every((e) => e.key !== undefined)).toBe(true);
@@ -803,7 +803,7 @@ describe("neo4j ↔ json count parity — full depth (issue #27)", () => {
     // Non-vacuous: the fixture really produces parallel edges between one endpoint pair for both
     // families (per-var DDG; a conditional's true/false CFG_NEXT pair) — the collapse the `_k`
     // discriminant exists to prevent. Guards against the fixture ever losing that shape.
-    for (const type of ["DDG", "CFG_NEXT"] as const) {
+    for (const type of ["TS_DDG", "TS_CFG_NEXT"] as const) {
       const pairs = new Map<string, number>();
       for (const e of monoRows.edges.filter((e) => e.type === type)) {
         const pair = `${e.from.value}${e.to.value}`;
diff --git a/test/synthesized-nodes.test.ts b/test/synthesized-nodes.test.ts
index f250f16..0e13ed3 100644
--- a/test/synthesized-nodes.test.ts
+++ b/test/synthesized-nodes.test.ts
@@ -1,7 +1,7 @@
 /**
  * Issue #13 (schema v2): Jelly's synthesized anonymous-callback signatures must materialize as
  * graph nodes so their CALLS edges resolve instead of being silently dropped by the MATCH-based
- * Cypher writer. Under v2 they are homed as `:CanNode:AnonymousCallable` nodes with an ordinal
+ * Cypher writer. Under v2 they are homed as `:CanNode:TSAnonymousCallable` nodes with an ordinal
  * `<enclosing-callable-id>@<line>:<col>` id, and the call graph references that id.
  */
 import { describe, expect, test } from "bun:test";
@@ -41,15 +41,15 @@ describe("synthesized anonymous-callable nodes (schema v2)", () => {
     expect(anonId).toBe(`${fooId}@3:10`);
   });
 
-  test("emits a :CanNode:AnonymousCallable node for it", () => {
+  test("emits a :CanNode:TSAnonymousCallable node for it", () => {
     const n = rows.nodes.find((n) => n.value === anonId);
     expect(n?.labels[0]).toBe("CanNode");
-    expect(n?.labels).toContain("AnonymousCallable");
+    expect(n?.labels).toContain("TSAnonymousCallable");
     expect(n?.props.start_line).toBe(3);
   });
 
   test("the CALLS edge to the anonymous callable resolves (was silently dropped before)", () => {
-    const e = rows.edges.find((e) => e.type === "CALLS" && e.to.value === anonId);
+    const e = rows.edges.find((e) => e.type === "TS_CALLS" && e.to.value === anonId);
     expect(e?.from.value).toBe(fooId);
   });
 });

From 66afcc3b5dcbae9cafdacf88136a62d117d5fb22 Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Wed, 15 Jul 2026 01:12:14 -0400
Subject: [PATCH 27/32] fix(neo4j): force full bolt upsert on schema-version
 mismatch (closes #68)

---
 src/build/neo4j/bolt.ts        | 33 ++++++++++++++++++++++++++-------
 test/bolt-version-gate.test.ts | 10 ++++++++++
 2 files changed, 36 insertions(+), 7 deletions(-)
 create mode 100644 test/bolt-version-gate.test.ts

diff --git a/src/build/neo4j/bolt.ts b/src/build/neo4j/bolt.ts
index d30d82b..3278b14 100644
--- a/src/build/neo4j/bolt.ts
+++ b/src/build/neo4j/bolt.ts
@@ -21,7 +21,7 @@
 import type { Logger } from "../../utils";
 import type { EdgeRow, GraphRows, NodeRow, Prop } from "./rows";
 import { chunk } from "./rows";
-import { CONSTRAINTS, INDEXES } from "./schema";
+import { CONSTRAINTS, INDEXES, SCHEMA_VERSION } from "./schema";
 
 export interface BoltConfig {
   uri: string;
@@ -33,6 +33,12 @@ export interface BoltConfig {
 const DESCENDANTS = "[:TS_DECLARES|TS_HAS_METHOD|TS_HAS_FIELD|TS_HAS_BODY_NODE*1..]";
 const BATCH = 1000;
 
+/** #68: a DB written by a different schema version must be fully re-upserted, not hash-diffed —
+ * otherwise unchanged modules keep the old label vocabulary while :Application advertises the new. */
+export function shouldForceFullUpsert(dbVersion: string | null, producerVersion: string): boolean {
+  return dbVersion !== producerVersion;
+}
+
 export async function boltWriter(
   rows: GraphRows,
   cfg: BoltConfig,
@@ -65,7 +71,20 @@ export async function boltWriter(
       }
     }
 
-    // 2. diff content_hash.
+    // 2. read schema version and decide if we need to force a full upsert.
+    let dbSchemaVersion: string | null = null;
+    await withSession(session, async (s) => {
+      const res = await s.run("MATCH (a:Application) RETURN a.schema_version AS v LIMIT 1");
+      dbSchemaVersion = res.records[0]?.get("v") ?? null;
+    });
+    const forceAll = shouldForceFullUpsert(dbSchemaVersion, SCHEMA_VERSION);
+    if (forceAll) {
+      log.info(
+        `neo4j(bolt): schema ${dbSchemaVersion ?? "(none)"} → ${SCHEMA_VERSION}, full upsert forced`,
+      );
+    }
+
+    // 3. diff content_hash.
     const dbHash = new Map<string, string | null>();
     await withSession(session, async (s) => {
       const res = await s.run("MATCH (m:TSModule) RETURN m._module AS k, m.content_hash AS h");
@@ -74,17 +93,17 @@ export async function boltWriter(
     const changed = new Set<string>();
     for (const [m, nodes] of byModule) {
       const rowHash = hashOf(nodes, m);
-      if (!dbHash.has(m) || rowHash === undefined || rowHash !== dbHash.get(m)) changed.add(m);
+      if (forceAll || !dbHash.has(m) || rowHash === undefined || rowHash !== dbHash.get(m)) changed.add(m);
     }
     log.info(
       `neo4j(bolt): ${byModule.size} modules (${changed.size} changed), ${shared.length} shared nodes, ` +
         `${rows.edges.length} edges`,
     );
 
-    // 3. shared nodes are always upserted (MERGE-only).
+    // 4. shared nodes are always upserted (MERGE-only).
     await upsertNodes(session, neo4j, shared);
 
-    // 4. per changed module: purge owned edges + vanished decls, then upsert its nodes.
+    // 5. per changed module: purge owned edges + vanished decls, then upsert its nodes.
     for (const m of changed) {
       const nodes = byModule.get(m)!;
       const keys = nodes.map((n) => n.value);
@@ -100,14 +119,14 @@ export async function boltWriter(
       await upsertNodes(session, neo4j, nodes);
     }
 
-    // 5. upsert edges owned by a changed module (owner = source node's module) or shared.
+    // 6. upsert edges owned by a changed module (owner = source node's module) or shared.
     const edges = rows.edges.filter((e) => {
       const owner = moduleOf.get(e.from.value);
       return owner === undefined || changed.has(owner);
     });
     await upsertEdges(session, neo4j, edges);
 
-    // 6. orphan prune — only safe on a full run (a targeted run can't tell deleted from untargeted).
+    // 7. orphan prune — only safe on a full run (a targeted run can't tell deleted from untargeted).
     if (fullRun) {
       const present = [...byModule.keys()];
       await withSession(session, async (s) => {
diff --git a/test/bolt-version-gate.test.ts b/test/bolt-version-gate.test.ts
new file mode 100644
index 0000000..8c14940
--- /dev/null
+++ b/test/bolt-version-gate.test.ts
@@ -0,0 +1,10 @@
+import { describe, expect, test } from "bun:test";
+import { shouldForceFullUpsert } from "../src/build/neo4j/bolt";
+
+describe("bolt version gate (#68)", () => {
+  test("mismatch or absent stored version forces a full upsert", () => {
+    expect(shouldForceFullUpsert("1.1.0", "2.0.0")).toBe(true);
+    expect(shouldForceFullUpsert(null, "2.0.0")).toBe(true);
+    expect(shouldForceFullUpsert("2.0.0", "2.0.0")).toBe(false);
+  });
+});

From c903a16972ac5204eb7b416df70363c5a7d83dc7 Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Wed, 15 Jul 2026 01:34:08 -0400
Subject: [PATCH 28/32] fix(neo4j): clean legacy pre-2.0.0 residue on
 version-gated migration; scope + index bolt lookups
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A 2.0.0 push onto a 1.1.0 DB left the whole 1.x subgraph orphaned and
poisonous: old nodes carry twin TS labels so they match v2 queries, two
:Application nodes make the version read nondeterministic, and the
vanished-decl sweep never removed them (their id is null → three-valued
logic dropped the row).

- Legacy-generation wipe when the version gate forces a full upsert:
  detect-and-delete 1.x _module carriers, shared External/Package/Decorator
  nodes, and the id-less :Application in one idempotent step before the
  per-module loop. Unanchored on purpose (legacy nodes lack :CanNode).
- Null-guard the vanished-decl sweep (x.id IS NULL OR NOT x.id IN keys).
- Scope the schema-version read to this app's :Application {id} so a shared
  DB can't surface a foreign analyzer's version.
- Anchor the per-module edge-delete and decl sweep on (:CanNode {_module})
  and add the cannode_module index to back them; regenerate schema.neo4j.json.
---
 schema.neo4j.json              |  3 +-
 src/build/neo4j/bolt.ts        | 64 ++++++++++++++++++++++++++++++----
 src/build/neo4j/index.ts       |  2 +-
 src/build/neo4j/schema.ts      |  3 ++
 test/bolt-version-gate.test.ts | 29 ++++++++++++++-
 5 files changed, 91 insertions(+), 10 deletions(-)

diff --git a/schema.neo4j.json b/schema.neo4j.json
index bb700cd..dc97524 100644
--- a/schema.neo4j.json
+++ b/schema.neo4j.json
@@ -395,6 +395,7 @@
   ],
   "indexes": [
     "CREATE INDEX callable_name IF NOT EXISTS FOR (c:TSCallable) ON (c.name)",
-    "CREATE INDEX cannode_kind IF NOT EXISTS FOR (n:CanNode) ON (n.kind)"
+    "CREATE INDEX cannode_kind IF NOT EXISTS FOR (n:CanNode) ON (n.kind)",
+    "CREATE INDEX cannode_module IF NOT EXISTS FOR (n:CanNode) ON (n._module)"
   ]
 }
diff --git a/src/build/neo4j/bolt.ts b/src/build/neo4j/bolt.ts
index 3278b14..2e1246b 100644
--- a/src/build/neo4j/bolt.ts
+++ b/src/build/neo4j/bolt.ts
@@ -39,6 +39,28 @@ export function shouldForceFullUpsert(dbVersion: string | null, producerVersion:
   return dbVersion !== producerVersion;
 }
 
+/**
+ * #46/#68 migration: wipe the pre-2.0.0 (schema 1.x) residue when the version gate forces a full
+ * upsert. Pushing 2.0.0 onto a 1.1.0 DB otherwise orphans the whole 1.x subgraph AND poisons v2
+ * queries — 1.x nodes carry twin TS labels (`:Module:TSModule`, `:Symbol:TSCallable`) so they match
+ * v2 patterns, and a second `:Application` (keyed on name, no `id`) makes the version read
+ * nondeterministic. These run ONCE, before the per-module loop; they are ordered, idempotent, and
+ * no-op on a fresh DB.
+ *
+ * They are intentionally UNANCHORED (no `:CanNode` guard on the MATCH) — that is the whole point:
+ * they must match the *legacy* nodes, which never carry `:CanNode`. Every v2 project-owned node DOES
+ * carry `:CanNode`, so the `AND NOT n:CanNode` predicate spares everything current. RETURN count so
+ * the caller can log what each statement removed.
+ */
+export const LEGACY_WIPE_STATEMENTS: readonly string[] = [
+  // 1.x project-owned nodes carried `_module` under twin labels (:Module:TSModule, …) but not :CanNode.
+  "MATCH (n) WHERE n._module IS NOT NULL AND NOT n:CanNode DETACH DELETE n RETURN count(n) AS wiped",
+  // 1.x shared nodes (externals / packages / decorators) had no `_module`; keyed on name, not id.
+  "MATCH (n) WHERE (n:External OR n:Package OR n:Decorator) AND NOT n:CanNode DETACH DELETE n RETURN count(n) AS wiped",
+  // The 1.x :Application node was keyed on `name`, so it has no `id`.
+  "MATCH (a:Application) WHERE a.id IS NULL DETACH DELETE a RETURN count(a) AS wiped",
+];
+
 export async function boltWriter(
   rows: GraphRows,
   cfg: BoltConfig,
@@ -71,17 +93,42 @@ export async function boltWriter(
       }
     }
 
-    // 2. read schema version and decide if we need to force a full upsert.
+    // 2. read schema version and decide if we need to force a full upsert. Scope the read to THIS
+    // app's :Application (by id) — an unscoped `MATCH (a:Application)` could read a foreign analyzer's
+    // node in a shared database and misjudge the version. Absent id → null → forces (safe default).
+    const appId = rows.nodes.find((n) => n.labels[0] === "Application")?.value ?? null;
     let dbSchemaVersion: string | null = null;
-    await withSession(session, async (s) => {
-      const res = await s.run("MATCH (a:Application) RETURN a.schema_version AS v LIMIT 1");
-      dbSchemaVersion = res.records[0]?.get("v") ?? null;
-    });
+    if (appId !== null) {
+      await withSession(session, async (s) => {
+        const res = await s.run(
+          "MATCH (a:Application {id: $appId}) RETURN a.schema_version AS v LIMIT 1",
+          { appId },
+        );
+        dbSchemaVersion = res.records[0]?.get("v") ?? null;
+      });
+    }
     const forceAll = shouldForceFullUpsert(dbSchemaVersion, SCHEMA_VERSION);
     if (forceAll) {
       log.info(
         `neo4j(bolt): schema ${dbSchemaVersion ?? "(none)"} → ${SCHEMA_VERSION}, full upsert forced`,
       );
+      // Detect-and-wipe the pre-2.0.0 subgraph in one step, BEFORE any new write, so stale twin-label
+      // nodes can't survive to poison v2 queries or the content-hash diff. Idempotent on fresh DBs.
+      const counts: number[] = [];
+      await withSession(session, async (s) => {
+        for (const stmt of LEGACY_WIPE_STATEMENTS) {
+          const res = await s.run(stmt);
+          const c = res.records[0]?.get("wiped");
+          counts.push(typeof c?.toNumber === "function" ? c.toNumber() : Number(c ?? 0));
+        }
+      });
+      const wiped = counts.reduce((a, b) => a + b, 0);
+      if (wiped > 0) {
+        log.info(
+          `neo4j(bolt): wiped ${wiped} legacy (pre-2.0.0) nodes ` +
+            `(module=${counts[0]}, shared=${counts[1]}, app=${counts[2]})`,
+        );
+      }
     }
 
     // 3. diff content_hash.
@@ -109,9 +156,12 @@ export async function boltWriter(
       const keys = nodes.map((n) => n.value);
       await withSession(session, async (s) => {
         await s.executeWrite(async (tx: any) => {
-          await tx.run(`MATCH (x {_module: $m})-[r]->() DELETE r`, { m });
+          // Anchor on :CanNode so these seek the module's index slice instead of scanning the whole
+          // store (and never touch non-CanNode nodes). The `x.id IS NULL` guard defends the sweep
+          // against a null key — three-valued logic would otherwise drop the row from `NOT x.id IN`.
+          await tx.run(`MATCH (x:CanNode {_module: $m})-[r]->() DELETE r`, { m });
           await tx.run(
-            `MATCH (x {_module: $m}) WHERE NOT x.id IN $keys DETACH DELETE x`,
+            `MATCH (x:CanNode {_module: $m}) WHERE x.id IS NULL OR NOT x.id IN $keys DETACH DELETE x`,
             { m, keys },
           );
         });
diff --git a/src/build/neo4j/index.ts b/src/build/neo4j/index.ts
index 1c70311..e94820d 100644
--- a/src/build/neo4j/index.ts
+++ b/src/build/neo4j/index.ts
@@ -3,6 +3,6 @@
 export { project } from "./project";
 export { renderCypher } from "./cypher";
 export { boltWriter, type BoltConfig } from "./bolt";
-export { SCHEMA_VERSION, TS_PREFIX, buildSchemaDocument, NODE_LABELS, REL_TYPES, MARKER_LABELS } from "./schema";
+export { SCHEMA_VERSION, TS_PREFIX, buildSchemaDocument, NODE_LABELS, REL_TYPES, MARKER_LABELS, CONSTRAINTS, INDEXES } from "./schema";
 export type { SchemaDocument } from "./schema";
 export type { GraphRows, NodeRow, EdgeRow } from "./rows";
diff --git a/src/build/neo4j/schema.ts b/src/build/neo4j/schema.ts
index 84fcc99..a25165b 100644
--- a/src/build/neo4j/schema.ts
+++ b/src/build/neo4j/schema.ts
@@ -194,6 +194,9 @@ export const CONSTRAINTS: readonly string[] = uniquenessConstraints();
 export const INDEXES: readonly string[] = [
   "CREATE INDEX callable_name IF NOT EXISTS FOR (c:TSCallable) ON (c.name)",
   "CREATE INDEX cannode_kind IF NOT EXISTS FOR (n:CanNode) ON (n.kind)",
+  // Backs the bolt writer's per-module edge-delete + vanished-decl sweep, which anchor on
+  // `(:CanNode {_module})` — without this they would scan the whole node store.
+  "CREATE INDEX cannode_module IF NOT EXISTS FOR (n:CanNode) ON (n._module)",
 ];
 
 export interface SchemaDocument {
diff --git a/test/bolt-version-gate.test.ts b/test/bolt-version-gate.test.ts
index 8c14940..c1f3507 100644
--- a/test/bolt-version-gate.test.ts
+++ b/test/bolt-version-gate.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { shouldForceFullUpsert } from "../src/build/neo4j/bolt";
+import { LEGACY_WIPE_STATEMENTS, shouldForceFullUpsert } from "../src/build/neo4j/bolt";
 
 describe("bolt version gate (#68)", () => {
   test("mismatch or absent stored version forces a full upsert", () => {
@@ -8,3 +8,30 @@ describe("bolt version gate (#68)", () => {
     expect(shouldForceFullUpsert("2.0.0", "2.0.0")).toBe(false);
   });
 });
+
+describe("legacy (pre-2.0.0) wipe (#46)", () => {
+  test("wipes the three legacy node classes, in order, unanchored but CanNode-guarded", () => {
+    expect(LEGACY_WIPE_STATEMENTS).toHaveLength(3);
+
+    // (1) project-owned twin-label nodes: matched by `_module`, spared iff :CanNode.
+    expect(LEGACY_WIPE_STATEMENTS[0]).toBe(
+      "MATCH (n) WHERE n._module IS NOT NULL AND NOT n:CanNode DETACH DELETE n RETURN count(n) AS wiped",
+    );
+    // (2) 1.x shared nodes (no `_module`): externals / packages / decorators, spared iff :CanNode.
+    expect(LEGACY_WIPE_STATEMENTS[1]).toBe(
+      "MATCH (n) WHERE (n:External OR n:Package OR n:Decorator) AND NOT n:CanNode DETACH DELETE n RETURN count(n) AS wiped",
+    );
+    // (3) the 1.x :Application node, keyed on name → no `id`.
+    expect(LEGACY_WIPE_STATEMENTS[2]).toBe(
+      "MATCH (a:Application) WHERE a.id IS NULL DETACH DELETE a RETURN count(a) AS wiped",
+    );
+
+    // Each is intentionally UNANCHORED on the MATCH (no :CanNode label) — it must reach legacy nodes —
+    // yet every one guards current v2 data with an explicit `NOT n:CanNode` / `a.id IS NULL` predicate.
+    for (const stmt of LEGACY_WIPE_STATEMENTS) {
+      expect(stmt).not.toContain("MATCH (n:CanNode");
+      expect(stmt).toContain("DETACH DELETE");
+      expect(stmt).toContain("RETURN count(");
+    }
+  });
+});

From cd427ad9c905bffe7e2ad02d6c4aca21b4f4d524 Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Wed, 15 Jul 2026 01:34:25 -0400
Subject: [PATCH 29/32] =?UTF-8?q?test(neo4j):=20derive=20container-suite?=
 =?UTF-8?q?=20expectations=20from=20the=20catalog;=20add=201.1.0=E2=86=922?=
 =?UTF-8?q?.0.0=20migration=20scenario?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace the stale v1 magic numbers (constraints ≥ 8, indexes ≥ 11) with
counts derived from the exported CONSTRAINTS/INDEXES catalog. Add a
migration scenario: seed a minimal schema-1.1.0 graph (twin labels, an
id-less :Application), run a full 2.0.0 bolt push against the same DB, and
assert exactly one :Application survives (id set, version 2.0.0), no
_module-carrying non-:CanNode residue remains, and TSModule count matches
the fixture (no duplicates).
---
 test/neo4j-bolt.test.ts | 55 ++++++++++++++++++++++++++++++++++++++---
 1 file changed, 51 insertions(+), 4 deletions(-)

diff --git a/test/neo4j-bolt.test.ts b/test/neo4j-bolt.test.ts
index 9ac5559..7376411 100644
--- a/test/neo4j-bolt.test.ts
+++ b/test/neo4j-bolt.test.ts
@@ -12,7 +12,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { Neo4jContainer, type StartedNeo4jContainer } from "@testcontainers/neo4j";
 import neo4j, { type Driver } from "neo4j-driver";
-import { type BoltConfig, boltWriter, project } from "../src/build/neo4j";
+import { type BoltConfig, boltWriter, CONSTRAINTS, INDEXES, project } from "../src/build/neo4j";
 import { analyze } from "../src/core";
 import type { AnalysisOptions } from "../src/options";
 import { Logger } from "../src/utils";
@@ -105,9 +105,14 @@ containerSuite("neo4j bolt writer", () => {
       expect(canNode).toBeGreaterThan(0);
       expect(kinds).toBe(canNode);
 
-      // Constraints + indexes were created up front.
-      expect(await num("SHOW CONSTRAINTS YIELD name RETURN count(*)")).toBeGreaterThanOrEqual(8);
-      expect(await num("SHOW INDEXES YIELD name RETURN count(*)")).toBeGreaterThanOrEqual(11);
+      // Constraints + indexes were created up front. Expectations derive from the catalog (a
+      // uniqueness constraint also spawns a backing index, so SHOW INDEXES only grows from here).
+      expect(await num("SHOW CONSTRAINTS YIELD name RETURN count(*)")).toBeGreaterThanOrEqual(
+        CONSTRAINTS.length,
+      );
+      expect(await num("SHOW INDEXES YIELD name RETURN count(*)")).toBeGreaterThanOrEqual(
+        INDEXES.length,
+      );
 
       // A known resolved call edge from the fixture (index.ts calls services.announce).
       expect(
@@ -151,4 +156,46 @@ containerSuite("neo4j bolt writer", () => {
     },
     120_000,
   );
+
+  test(
+    "migrates a 1.1.0-shaped graph to 2.0.0, wiping legacy residue (#46)",
+    async () => {
+      // Seed a minimal schema-1.1.0 graph on a clean store: twin labels, the old
+      // name/file_key/signature keys, and an :Application keyed on `name` (no `id`).
+      const seed = driver.session();
+      try {
+        await seed.run("MATCH (n) DETACH DELETE n");
+        await seed.run(
+          "CREATE (:Application {name:'sample-app', schema_version:'1.1.0'}) " +
+            "CREATE (:Module:TSModule {file_key:'x.ts', _module:'x.ts', content_hash:'stale'}) " +
+            "CREATE (:Symbol:TSCallable {signature:'x', _module:'x.ts'})",
+        );
+      } finally {
+        await seed.close();
+      }
+
+      // A full 2.0.0 push against the same DB must detect the version mismatch and wipe the residue.
+      const rows = project(await analyze(optsFor()), "sample-app");
+      await boltWriter(rows, cfg, log, true);
+
+      // Exactly one :Application survives — the fresh v2 one (id set, version bumped). The 1.x app,
+      // keyed on name with no id, was wiped, so the version read is no longer nondeterministic.
+      expect(await num("MATCH (a:Application) RETURN count(a)")).toBe(1);
+      expect(
+        await num(
+          "MATCH (a:Application) WHERE a.id IS NOT NULL AND a.schema_version = '2.0.0' RETURN count(a)",
+        ),
+      ).toBe(1);
+
+      // No legacy twin-label residue remains (would-be poison for v2 label queries).
+      expect(
+        await num("MATCH (n) WHERE n._module IS NOT NULL AND NOT n:CanNode RETURN count(n)"),
+      ).toBe(0);
+
+      // The stale 'x.ts' :TSModule seed did not survive as a duplicate — exactly the fixture's modules.
+      const fixtureModules = rows.nodes.filter((n) => n.labels.includes("TSModule")).length;
+      expect(await num("MATCH (m:TSModule) RETURN count(m)")).toBe(fixtureModules);
+    },
+    120_000,
+  );
 });

From e03966a4016e9d70df3cf5c87a951d1a234f202f Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Wed, 15 Jul 2026 01:35:06 -0400
Subject: [PATCH 30/32] ci: typecheck + tests + container suite on pull
 requests

Add a minimal CI workflow (pull_request to main + push to main): a single
ubuntu-latest job that checks out, sets up Bun, installs with a frozen
lockfile, runs typecheck and the default test suite, then runs the
container-gated Neo4j bolt suite with RUN_CONTAINER_TESTS=1 (ubuntu runners
ship Docker, so testcontainers works out of the box).
---
 .github/workflows/ci.yml | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 .github/workflows/ci.yml

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..2d9d084
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,30 @@
+name: CI
+
+on:
+  pull_request:
+    branches: [main]
+  push:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+
+      - name: Set up Bun
+        uses: oven-sh/setup-bun@v2
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Typecheck
+        run: bun run typecheck
+
+      - name: Unit + conformance tests
+        run: bun test
+
+      # Container suite is opt-in; ubuntu-latest ships Docker, so testcontainers works out of the box.
+      - name: Neo4j bolt container tests
+        run: RUN_CONTAINER_TESTS=1 bun test test/neo4j-bolt.test.ts

From 38bd030ce3f756fdb9e9ba9552ff0206b19d5de7 Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Wed, 15 Jul 2026 01:35:42 -0400
Subject: [PATCH 31/32] chore: fix stale schema/docs comments; drop orphaned
 TSSymbol

- src/schema/schema.ts header: the spine field is external_symbols, not the
  nonexistent 'entrypoints'.
- delete the orphaned TSSymbol interface (zero references).
- rows.ts NodeRef.keyProp comment: only 'id' exists at schema v2.
- project.ts idOf doc: it IS the identity (pass-through), not an @local strip.
---
 src/build/neo4j/project.ts |  2 +-
 src/build/neo4j/rows.ts    |  2 +-
 src/schema/schema.ts       | 13 +------------
 3 files changed, 3 insertions(+), 14 deletions(-)

diff --git a/src/build/neo4j/project.ts b/src/build/neo4j/project.ts
index 2c1fb0f..5120636 100644
--- a/src/build/neo4j/project.ts
+++ b/src/build/neo4j/project.ts
@@ -203,7 +203,7 @@ interface Edge {
 }
 const edges = (x: unknown): Edge[] => (Array.isArray(x) ? (x as Edge[]) : []);
 
-/** Strip the `@local` suffix from a fully-qualified cross-edge endpoint — it IS the graph node id. */
+/** A cross-edge endpoint is already the graph node's can:// id — pass it through unchanged. */
 const idOf = (endpoint: string): string => endpoint;
 
 function moduleKeyOf(mod: V2Module): string {
diff --git a/src/build/neo4j/rows.ts b/src/build/neo4j/rows.ts
index 437cd4f..35d2107 100644
--- a/src/build/neo4j/rows.ts
+++ b/src/build/neo4j/rows.ts
@@ -17,7 +17,7 @@ const CAN_NODE = "CanNode";
 /** How an edge addresses one of its endpoints: the label + key property to MATCH on, and value. */
 export interface NodeRef {
   label: string; // the label carrying the uniqueness constraint ("Application" | "CanNode")
-  keyProp: string; // "signature" | "file_key" | "name" | "qualified_name" | "id"
+  keyProp: string; // always "id" at schema v2 — every node is keyed on its can:// id
   value: string;
 }
 
diff --git a/src/schema/schema.ts b/src/schema/schema.ts
index 64959b2..df95f0f 100644
--- a/src/schema/schema.ts
+++ b/src/schema/schema.ts
@@ -2,7 +2,7 @@
  * The canonical CLDK analysis schema for TypeScript.
  *
  * Mirrors the identity-only Python schema (codeanalyzer-python/.../py_schema.py) field for
- * field on the invariant spine — `TSApplication { symbol_table, call_graph, entrypoints }`,
+ * field on the invariant spine — `TSApplication { symbol_table, call_graph, external_symbols }`,
  * `Module → Class/Callable` nesting, identity-only `TSCallEdge` whose `source`/`target` are
  * bare signature strings — and extends it at the leaves with TypeScript-native node kinds
  * (interface / type-alias / enum / namespace) and typed fields (generics, modifiers, ...).
@@ -63,17 +63,6 @@ export interface TSComment {
   end_column: number;
 }
 
-export interface TSSymbol {
-  name: string;
-  scope: string; // local | parameter | class | module | global
-  kind: string; // variable | parameter | property | function | class | interface | enum | type_alias | module
-  type: string | null;
-  qualified_name: string | null;
-  is_builtin: boolean;
-  lineno: number;
-  col_offset: number;
-}
-
 export interface TSVariableDeclaration {
   span?: TSSpan; // schema-v2 precise span
   name: string;

From 27f45d1b0b04ccf76efc7b9a3f8ca0b2ef8dbed6 Mon Sep 17 00:00:00 2001
From: Rahul Krishna <rkrsn@ibm.com>
Date: Wed, 15 Jul 2026 02:01:10 -0400
Subject: [PATCH 32/32] fix(call-graph): resolve external
 property/method-signature members via the checker (#53)

---
 src/schema/signatures.ts                       | 14 ++++++++++++++
 test/external-resolution.test.ts               | 14 ++++++++++++++
 test/fixtures/sample-app/src/external-calls.ts | 16 ++++++++++++++++
 3 files changed, 44 insertions(+)

diff --git a/src/schema/signatures.ts b/src/schema/signatures.ts
index 43f0f08..e26642e 100644
--- a/src/schema/signatures.ts
+++ b/src/schema/signatures.ts
@@ -160,6 +160,20 @@ export function resolveCalleeSignature(
     }
     return null;
   }
+
+  // EXTERNAL-ONLY widening (#53): framework .d.ts files declare callable members as property
+  // signatures or function-typed property declarations (`get: IRouterMatcher` in @types/express,
+  // `rxSession: (cfg?) => RxSession` in neo4j-driver) — kinds isCallableDecl deliberately excludes
+  // for the in-project path (a project property is a field, not a callable). Being the callee of
+  // this very call expression is evidence enough that the member is callable, so accept these
+  // kinds when — and only when — the declaration homes outside the project.
+  if (Node.isPropertySignature(decl) || Node.isPropertyDeclaration(decl)) {
+    const home = externalHomeOf(decl);
+    if (home) {
+      const member = safeName(decl);
+      return { signature: `${home.module}.${member}`, isConstructor: false, external: { module: home.module, member } };
+    }
+  }
   return null;
 }
 
diff --git a/test/external-resolution.test.ts b/test/external-resolution.test.ts
index e8ed974..180915d 100644
--- a/test/external-resolution.test.ts
+++ b/test/external-resolution.test.ts
@@ -79,11 +79,25 @@ describe("external call resolution (#53)", () => {
     expect(ext.some((s) => /^commander\.(name|description|parse)$/.test(s))).toBe(true);
     // default-import member call (`neo4j.driver(...)`) → external neo4j-driver.driver.
     expect(ext.some((s) => s.startsWith("neo4j-driver") && s.includes("driver"))).toBe(true);
+    // member calls on a LOCAL external-typed receiver (`d` — no import binding, checker-only):
+    // MethodDeclaration members already resolved; the module is neo4j-driver-core because that
+    // transitive package is where `Driver.session` is actually declared.
+    expect(ext).toContain("neo4j-driver-core.session");
+    // function-typed PropertyDeclaration member (`rxSession: (cfg?) => RxSession`) — the
+    // framework-.d.ts shape (Express `app.get`, RxJS `subscribe`) that #53 must resolve.
+    expect(ext).toContain("neo4j-driver.rxSession");
+    // PropertySignature member on a nested receiver (`neo4j.auth.basic` — fallback-unreachable).
+    expect(ext).toContain("neo4j-driver.basic");
     // a TS-stdlib global (eval, from lib.*.d.ts) with no import at all — checker-resolved, new in #53.
     expect(ext.some((s) => s.endsWith(".eval"))).toBe(true);
 
     const calls = callsIn(app, "src/external-calls.ts");
     expect(calls.length).toBeGreaterThan(0);
+    // The checker-only member calls got their callee backfilled in place on the call site.
+    const rx = calls.find((c) => c.method_name === "rxSession");
+    expect(rx?.callee_signature).toBe("neo4j-driver.rxSession");
+    const session = calls.find((c) => c.method_name === "session");
+    expect(session?.callee_signature).toBe("neo4j-driver-core.session");
     const resolved = calls.filter((c) => c.callee_signature != null);
     expect(resolved.length / calls.length).toBeGreaterThanOrEqual(0.75);
   });
diff --git a/test/fixtures/sample-app/src/external-calls.ts b/test/fixtures/sample-app/src/external-calls.ts
index a6b890e..9cd52d1 100644
--- a/test/fixtures/sample-app/src/external-calls.ts
+++ b/test/fixtures/sample-app/src/external-calls.ts
@@ -39,6 +39,22 @@ export function makesDriver(): unknown {
   return neo4j.driver("bolt://localhost");
 }
 
+/**
+ * Member calls on a LOCAL receiver of external type — the fallback has no binding for `d`, so only
+ * the checker can attribute these. Each line pins a different declaration kind in the framework's
+ * .d.ts, the Express/RxJS pattern from #53 (`res.json(...)`, `observable.subscribe(...)`):
+ *   - `d.session()`   → MethodDeclaration (in neo4j-driver-core, where the decl actually lives)
+ *   - `d.rxSession()` → function-typed PropertyDeclaration (`rxSession: (cfg?) => RxSession`)
+ *   - `neo4j.auth.basic()` → PropertySignature on a nested receiver (`neo4j.auth` is a property
+ *     access, not an import binding, so the fallback can't reach it either)
+ */
+export function makesSession(): unknown {
+  const d = neo4j.driver("bolt://localhost", neo4j.auth.basic("user", "pass"));
+  const s = d.session();
+  d.rxSession();
+  return s;
+}
+
 /** a lib.*.d.ts global with no import at all — only the checker can classify its home. */
 export function unsafeEval(raw: string): unknown {
   return eval(raw);