Add ADR-014 and DDD for semantic pipeline unification sprint

ADR-014: Wire all existing components in a single pass. No backward compat,
no fallback paths, no duplicate systems. Delete dead code. Edge colour =
domain gradient weighted by relationship power.

DDD: 4 bounded contexts (Ingestion, Physics, Analytics, Rendering) with
shared EdgeType enum (8 types, weight table, spring multipliers). Every
OntologyBlock relationship becomes a Neo4j edge. Every edge type flows
to the GPU. Every analytics result flows to the client.

Co-Authored-By: claude-flow <[email protected]>

Author: Roo Code

docs/adr-014-semantic-pipeline-unification.md

@@ -0,0 +1,56 @@
+# ADR-014: Semantic Pipeline Unification
+
+**Date**: 2026-03-25
+**Status**: ACCEPTED
+**Decision**: Wire all existing semantic pipeline components into a single data flow. No new systems. No backward compatibility. No fallbacks.
+
+## Context
+
+The VisionFlow codebase contains a complete semantic pipeline — parsers, Neo4j adapters, GPU actors, CUDA kernels, constraint translators, binary protocol fields — built over months but never connected end-to-end. 7 data loss points cause 8/9 relationship types to be dropped, 110K axioms to sit isolated, and GPU analytics to return zeros.
+
+## Decision
+
+**Single pass, single sprint. Delete all fallback paths. Wire source→sink directly.**
+
+### Principles
+1. **Markdown is truth** — every relationship in an OntologyBlock becomes a Neo4j edge
+2. **No fallback edge generation** — delete `generate_edges_from_metadata()` and `generate_edges_from_labels()`
+3. **No dual-path loading** — `load_graph()` loads ONE unified graph (GraphNode + OwlClass edges combined)
+4. **Edge type flows to GPU** — CSR carries edge_type buffer alongside col_indices
+5. **Analytics flow back** — ClusteringActor writes results, binary protocol carries them, client reads them
+6. **Edge colour = relationship power** — gradient from source domain colour to target domain colour, weighted by relationship strength
+
+### What We Delete
+- `generate_edges_from_metadata()` (dead code, never called)
+- `generate_edges_from_labels()` (fallback that produces low-quality namespace-only edges)
+- `if iri_to_id.is_empty()` branch in `load_graph()` (either/or path selection)
+- `app_state.node_analytics` empty HashMap pattern (replace with write path)
+
+### What We Wire
+- `neo4j_ontology_repository::add_owl_class()` → store ALL relationship types as `:RELATES` edges
+- `neo4j_adapter::load_graph()` → single query: EDGE + SUBCLASS_OF + RELATES
+- `force_compute_actor` → CSR with `edge_types: DeviceBuffer<u8>`
+- `clustering_actor` → `ClientCoordinatorActor` → `node_analytics` → binary V3
+- `ontology_constraint_actor` → `apply_ontology_constraints()` (remove dead_code annotation)
+- `semantic_forces_actor` → receive `source_domain` as type_id, activate type clustering
+
+### Edge Colour Model
+Edges render as gradient tubes:
+- **Source end**: domain colour of source node (AI=#4FC3F7, BC=#81C784, MV=#CE93D8, etc.)
+- **Target end**: domain colour of target node
+- **Width**: `edge.weight` (hierarchical=2.5, structural=1.5, dependency=1.5, associative=1.0, bridge=1.0)
+- **Opacity**: `relationship_power = weight * (1 + log(edge_count_between_pair))`
+- Cross-domain edges create visible colour gradients between domain clusters
+
+## Consequences
+
+- Breaking change: edge count jumps from ~490 to ~1,500+
+- Physics will need re-settle with new edge topology
+- Cluster hulls will naturally separate into domain groups
+- Client edge rendering needs gradient material (already partially in `GlassEdges` with `useGradient: true`)
+
+## Alternatives Considered
+
+- **Keep fallback paths**: Rejected — they mask data quality issues and add code complexity
+- **New edge storage system**: Rejected — existing `:EDGE`/`:RELATES`/`:SUBCLASS_OF` pattern is sufficient
+- **Client-side edge synthesis**: Rejected — server is source of truth, client should only render

docs/ddd-semantic-pipeline.md

@@ -0,0 +1,102 @@
+# DDD: Semantic Pipeline — Bounded Contexts
+
+**Date**: 2026-03-25
+
+## Domain Model
+
+```
+Markdown Source (Aggregate Root)
+  ├── OntologyBlock (Value Object)
+  │     ├── is_subclass_of: Vec<String>     → "hierarchical" edge, weight 2.5
+  │     ├── has_part: Vec<String>           → "structural" edge, weight 1.5
+  │     ├── is_part_of: Vec<String>         → "structural" edge, weight 1.5
+  │     ├── requires: Vec<String>           → "dependency" edge, weight 1.5
+  │     ├── depends_on: Vec<String>         → "dependency" edge, weight 1.5
+  │     ├── enables: Vec<String>            → "dependency" edge, weight 1.5
+  │     ├── relates_to: Vec<String>         → "associative" edge, weight 1.0
+  │     ├── bridges_to: Vec<String>         → "bridge" edge, weight 1.0
+  │     └── bridges_from: Vec<String>       → "bridge" edge, weight 1.0
+  ├── Wikilinks (Value Object)              → "explicit_link" edge, weight 1.0
+  └── Namespace Prefix (derived)            → "namespace" edge, weight 0.3
+
+Neo4j (Repository)
+  ├── :GraphNode — display nodes
+  ├── :OwlClass — ontology concepts
+  ├── :EDGE — wikilink + relationship edges (with relation_type, owl_property_iri)
+  ├── :SUBCLASS_OF — hierarchy edges
+  ├── :RELATES — non-hierarchical ontology edges (NEW)
+  └── :OwlAxiom — reasoner output (materialised → SUBCLASS_OF)
+
+GPU Physics (Domain Service)
+  ├── ForceComputeActor — Barnes-Hut forces + edge springs
+  │     └── CSR graph: (col_indices, edge_weights, edge_types)
+  ├── SemanticForcesActor — type clustering + DAG layout
+  │     └── Reads: node type_id (domain), edge_type for spring differentiation
+  ├── OntologyConstraintActor — axiom-derived constraints
+  │     └── Reads: DisjointWith → separation, SubClassOf → clustering
+  ├── ClusteringActor — k-means / louvain
+  │     └── Writes: cluster_id per node → app_state.node_analytics
+  └── AnomalyDetectionActor — LOF / z-score
+        └── Writes: anomaly_score per node → app_state.node_analytics
+
+Client Rendering (Presentation)
+  ├── Binary Protocol V3: [pos, vel, cluster_id, anomaly_score, community_id]
+  ├── Node colour: domain palette (AI=#4FC3F7, BC=#81C784, MV=#CE93D8, ...)
+  ├── Edge gradient: source_domain_colour → target_domain_colour
+  ├── Edge width: relationship weight (2.5 hierarchical → 1.0 associative)
+  └── ClusterHulls: convex hull per domain/cluster with domain colour
+```
+
+## Bounded Contexts
+
+### 1. Ingestion Context
+**Responsibility**: Markdown → Neo4j
+**Files**: github_sync_service.rs, ontology_parser.rs, knowledge_graph_parser.rs, neo4j_ontology_repository.rs, neo4j_adapter.rs
+**Invariant**: Every relationship in an OntologyBlock becomes a Neo4j edge with type and weight
+
+### 2. Physics Context
+**Responsibility**: Neo4j → GPU forces → settled positions
+**Files**: graph_state_actor.rs, force_compute_actor.rs, semantic_forces_actor.rs, ontology_constraint_actor.rs
+**Invariant**: Edge type influences spring strength. Domain membership influences clustering force.
+
+### 3. Analytics Context
+**Responsibility**: GPU clustering/anomaly → client metadata
+**Files**: clustering_actor.rs, anomaly_detection_actor.rs, app_state.rs, binary_protocol.rs
+**Invariant**: Every node has a cluster_id and anomaly_score delivered to the client
+
+### 4. Rendering Context
+**Responsibility**: Positions + metadata → visual output
+**Files**: GraphManager.tsx, ClusterHulls.tsx, GlassEdges, binaryProtocol.ts, graph.worker.ts
+**Invariant**: Edges are coloured by domain gradient. Nodes are coloured by cluster. Hulls wrap clusters.
+
+## Anti-Corruption Layer
+
+None. Single codebase, single data flow. The markdown parser IS the domain model. Everything downstream is a projection of the parsed OntologyBlock.
+
+## Edge Type Enum (shared across all contexts)
+
+```rust
+#[repr(u8)]
+pub enum EdgeType {
+    ExplicitLink = 0,   // [[wikilink]]
+    Hierarchical = 1,   // is-subclass-of (rdfs:subClassOf)
+    Structural = 2,     // has-part, is-part-of
+    Dependency = 3,     // requires, depends-on, enables
+    Associative = 4,    // relates-to
+    Bridge = 5,         // bridges-to, bridges-from
+    Namespace = 6,      // shared prefix grouping
+    Inferred = 7,       // whelk reasoner output
+}
+```
+
+Weight table:
+| EdgeType | Default Weight | Spring Multiplier | Colour Influence |
+|----------|---------------|-------------------|-----------------|
+| Hierarchical | 2.5 | 2.0x | Strong domain pull |
+| Structural | 1.5 | 1.5x | Medium clustering |
+| Dependency | 1.5 | 1.5x | Medium clustering |
+| Associative | 1.0 | 1.0x | Gentle grouping |
+| Bridge | 1.0 | 0.5x | Cross-domain (weaker) |
+| ExplicitLink | 1.0 | 1.0x | Standard spring |
+| Namespace | 0.3 | 0.3x | Weak grouping |
+| Inferred | 0.8 | 0.8x | Reasoner-derived |