The Entity Network — link analysis as a navigable graph

The Entity Network renders the canonical model as a navigable, grounded 3D graph where nodes are entities and edges are ties derived from shared observations.

Route: /network (view modes: network · geo · timeline) Files: app-entity-network.jsx (the surface + the 3D NetworkRenderer + <ActivityTimeline>) · app-graph-data.jsx (the data seam — window.graphData) Doctrine: Q10 — agent suggests, human commits (a proposed tie is dashed until a human confirms it) · grounding (every edge resolves to observations)

A list of entities tells you what exists; a graph tells you what's connected — and in intelligence work the connection is usually the point. The Entity Network renders the canonical model (§2) as a navigable, grounded graph: nodes are entities, edges are ties derived from shared observations and events. It is a way to navigate the model, not a separate data world.

The data seam (`app-graph-data.jsx`)

The UI never builds the graph itself; it asks window.graphData for it, so the layout/render is decoupled from the model the same way the DataLayer (§13) decouples the autonomy surfaces.

getSubgraph(pid, { minTie, entityTypes })  → { nodes, links } for a project
graphKpis(pid, { minTie })                 → node / edge / density / cluster counts
graphInsights(pid)                         → topConnectors, strongest bridges, suggested links
getActivitySeries(scope, { buckets })      → the per-bucket activity series (Pattern of Life, §15)
scoreDeviation(scope)                      → robust-z deviation + direction + grounding
updateLink(pid, id, patch)                 → confirm / dismiss a tie (Q10 commit)

A node carries id · label · type · val · metrics.centrality · flags. A link carries source · target · type · weight · status where status ∈ {confirmed, proposed, dismissed} — proposed is an agent-suggested tie awaiting a human.

Rendering — a 3D point cloud you can grab

NetworkRenderer is a canvas surface, not an SVG diagram. A two-stage force-directed layout runs once per dataset: community centroids are placed on a Fibonacci sphere and relaxed apart, then each node is pulled into a soft 3D blob around its centroid with capped repulsion + link springs. The result projects to a live point cloud:

Grab to rotate, scroll to zoom, drag a node to reposition. A slow auto-rotation runs until you interact (pause-able).
Nodes are glossy lit spheres — a radial highlight, a grounding shadow, depth-dimming front-to-back — so volume reads as it turns. Hubs carry a soft radial glow scaled by centrality.
Edges read the structure: intra-community ties take the community hue at low alpha; cross-community ties are faint grey bridges; agent-suggested ties are dashed (Q10) until confirmed.

What the graph surfaces

Communities, on their own. Nodes are coloured by detected community (a deterministic hub-assignment + size-ordered palette), so the clusters that matter — an ownership network, a fleet, a port of convenience — separate visually without anyone tagging them.
Centrality reveals the connectors. Node size and brightness track centrality; the bridge entity that ties two clusters together is the one to look at first. graphInsights lists the top connectors and strongest bridges in the side rail.
Three colour modes (toolbar COLOR: cycles): cluster (default), type (entity kind), risk (designated / exposed / clear). The legend top-left reflects the active mode.
Filters: a minimum-tie-strength slider and an entity-type filter prune the subgraph.
Selection → Entity Inspector. Click a node to open its panel (related ties, suspected links, jump to /entities/:id); each tie is one click from the observations that established it.

View modes

network — the 3D graph (default).
geo — the same entities placed on the map basemap (where a node has coordinates).
timeline — Pattern of Life (§15): an entity's activity against its baseline band.

Canvas pop-out from the chat (spec 16)

The Entity Network is a noun in the verbs-in-chat / nouns-on-canvas rule (§16). A chat launch widget's Show on graph dispatches insigz:network-focus { id }; the surface listens, switches to the network view, and selects that node. insigz:network-view { view } switches view modes. This is how an answer in chat ("…connected to the sanctioned entity") becomes a focused graph without the user hunting for it.

Grounding & the doctrine line

An edge exists because observations and events say it does. When an agent infers a relationship it does not draw it as fact — it stages a dashed, proposed link a human Accepts or Dismisses via updateLink (the same agent-drafts/human-commits line, Q10, that governs Watches in §13). Confirmed ties are solid; dismissed ties disappear from the layout.

Prototype boundary

Real now: the graphData seam + its full contract; the 3D force layout, projection, rotate/zoom/drag interaction, and depth-shaded sphere rendering; community detection + centrality + the colour modes; the tie filters; selection → inspector; the geo/timeline views; the insigz:network-focus / insigz:network-view canvas pop-outs; suggested-link confirm/dismiss. Deferred: edges derived from a live fused model (today they come from the seeded per-project subgraphs), GPU-scale rendering for thousand-node graphs, and the backend behind graphData (mirrors the §13 DataLayer swap).