The unifying typed graph.
Above every Vadyl plane sits the Plane Capability Graph — a Tier-1 typed projection that every plane contributes facets to. Resources, actions, triggers, measures, events, effects, policies, transforms become typed nodes with typed edges. Dangling edges fail closed. Schema mismatches fail closed. Unit incompatibilities fail closed — at compile time. The dashboard graph explorer, the agent planner, the automation compiler, the explainability projections all consume PCG as their typed truth.
Typed nodes. Typed edges. No glue.
Typed resources
Entities, fields, relations, indexes, surfaces, agents, automations, schedules, webhooks, identity providers — every canonical platform thing has a typed PlaneResourceKind ordinal.
Typed actions, triggers, measures
Reads, writes, dispatches, schedules, automations, effects, policies, transforms — typed at the graph level. Not strings. Not loose JSON. Closed discriminated unions.
Typed edges
PlaneEdgeKind. Every edge declares its semantic kind — reads / writes / triggers / observes / depends-on / publishes — and is validated against the typed nodes it connects.
Per-domain facet contributors
Each plane registers a narrow IPlaneCapabilityFacetContributor that adds its facets to the graph. The Automation plane contributes effects / policies / transforms. The Agent plane contributes plan operations. Surface compiler contributes routes.
Content-hashed
PlaneCapabilityGraphCompiler computes a deterministic content hash. No recompile if inputs unchanged. Coherent across instances via the same cache invalidation bus every other plane uses.
Branching-aware
PCG is compiled per project, per publication. Branch a sandbox, see the graph for that branch. Three-way merge handles graph-level conflicts.
Acyclic by construction
PCG cannot call back into the contract projection compiler — the projection compiler may consume PCG, not vice versa. The graph cannot reason about itself recursively.
Fail-closed validation
Dangling edges produce PCG_EDGE_FROM_DANGLING / PCG_EDGE_TO_DANGLING errors. Schema mismatches, unit incompatibilities, capability gaps — all fail at compile, never at runtime.
Universal consumer
Automation compiler, dashboard graph explorer, agent planner, explainability projections — they all consume PCG. One typed truth, no second authority.
Above every plane
Coherent across instances
Same DAG as everything else
Compile-time, not runtime
One typed truth, consumed everywhere.
Automation compiles against PCG. Agents plan against PCG. Dashboard explores PCG. Explainers project from PCG. No glue, no second graph.