This is a good moment to freeze the ontologies, because you now have enough clarity to separate three layers:

1. Nexus Universal Ontology (domain-agnostic primitives)
2. Adam’s Event Modeling Ontology (method primitives)
3. Event Modeling Extended (EMext) (your explicit implementation ontology)

Each serves a different purpose.

---

1. Nexus Ontology (Universal Truth Graph)

This is the highest abstraction layer.
It must work for:

• software systems
• education
• video production
• knowledge graphs
• physical processes

So the primitives should be domain-agnostic.

Behavioral primitives

Agent
Intent
Fact
Interpretation

Meaning:

Agent
  entity capable of action or decision

Intent
  a proposed action

Fact
  something that happened

Interpretation
  derived understanding of facts

Behavior loop:

Agent
  ↓
Intent
  ↓
Fact
  ↓
Interpretation
  ↓
Agent

---

Structural primitives

Concept
Context

Meaning:

Concept
  vocabulary element / semantic unit

Context
  boundary in which concepts are meaningful

---

Nexus Ontology Summary

Agent
Intent
Fact
Interpretation
Concept
Context

These are truth graph primitives.

Everything else is derived.

---

2. Adam’s Event Modeling Ontology

Event Modeling is a modeling method, not a universal ontology.

Core primitives used by Adam Dymitruk:

Actor
Command
Event
View
Slice
Timeline

Meaning:

Actor
  human or external system interacting with system

Command
  request for something to happen

Event
  fact that something happened

View
  filtered dataset derived from events

Slice
  minimal behavior unit (Command→Event or Event→View)

Timeline
  ordered sequence of slices

Automation concept:

Processor / Bot

Used when:

Event → View → Processor → Command

---

Event Modeling Ontology Summary

Actor
Command
Event
View
Slice
Timeline
Processor (optional)

This ontology is intentionally minimal for discovery workshops.

Implementation details are hidden.

---

3. Event Modeling Expanded (EMExt)

This is where you expose the hidden mechanisms.

EMExt makes the implicit parts explicit.

Core behavioral primitives

Agent
Trigger
Command
Handler
Event
Projection
View

Meaning:

Agent
  entity capable of triggering actions

Trigger
  mechanism that initiates a command

Command
  requested action

Handler
  implementation that evaluates command

Event
  fact produced by handler

Projection
  mechanism deriving data from events

View
  dataset derived from projections

Pipeline becomes:

Agent
  ↓
Trigger
  ↓
Command
  ↓
Handler
  ↓
Event
  ↓
Projection
  ↓
View

Automation becomes:

Event
  ↓
Projection
  ↓
View
  ↓
Bot Trigger
  ↓
Command

---

Rule layer (GWT)

EMExt explicitly models rule definitions.

Command slice rule:

GIVEN <events>
WHEN <command>
THEN <event>

Projection rule:

GIVEN <events>
WHEN <filter>
THEN <view>

---

4. How the three ontologies align

Nexus	Event Modeling	EMExt
Agent	Actor	Agent
Intent	Command	Command
Fact	Event	Event
Interpretation	View	View
—	—	Projection
—	—	Handler
—	—	Trigger
Concept	—	Concept
Context	—	Context

---

5. The important pattern

You can see the layering:

Nexus
   conceptual truth primitives

Event Modeling
   behavioral discovery method

EMExt
   executable system architecture

---

6. The really elegant reduction

All three ultimately center on the same loop:

Agent
  ↓
Intent
  ↓
Fact
  ↓
Interpretation
  ↓
Agent

Event Modeling simply maps that loop to software behavior.

---

7. Where your filesystem truth graph fits

Your POC likely models EMExt primitives as nodes.

Example graph:

Agent
  → Trigger
  → Command
  → Event
  → Projection
  → View

While Nexus primitives describe the semantics of the graph.

---

✅ So the stack becomes:

NEXUS
  Universal ontology

EVENT MODELING
  Behavioral modeling method

EMExt
  Explicit implementation ontology

---

If you'd like, the next step that could dramatically clarify your Nexus architecture is something most people never formalize but you’re very close to:

the difference between “Ontology” and “Physics” of a domain universe.

That concept would explain why your primitives behave the way they do and why the Event Modeling loop keeps appearing across domains.