Skip to content

The Complai Ecosystem

Three tools, one event-driven workflow. From domain discovery through temporal modeling to project bootstrapping — connected by the ComplaiEventEnvelope format.

Domain event streams
facet.json simulation scenariosTyped artifacts + events
upstream

Sift

Domain Discovery

Upstream domain modeling tool that captures the initial domain exploration — bounded contexts, aggregates, commands, events, value objects, invariants, policies, and sagas. Publishes structured building block events that Moment imports.

Published Events

BoundedContextDefinedAggregateAddedCommandDefinedEventDefinedValueObjectDefinedInvariantDefinedPolicyDefinedSagaDefined
Output: Domain event streams

From the blog

Introducing Signal-Driven Development The Gap Report: DDD's Missing Feedback Loop Event Storming Is a Language, Not a Workshop When JTBD Meets DDD
SDD Methodology SDD on GitHub Blog
core

Moment

Temporal DDD Modeling

Transforms .moment specification files into typed TypeScript implementations, Gherkin test scenarios, and specification documents. Imports Sift's domain events and enriches them with temporal modeling — flows, crossings, projections, and saga orchestration.

Published Events

SpecificationParsedTopologyDerivedArtifactsGeneratedDriftDetectedSchemaTransitioned
Output: Reconciliation events + typed artifacts

From the blog

AI Made My Architecture Deeper, Not Simpler The Coherence Problem The Classification Gap: The Bug That Passes Every Test The Single-Seat Architect
Moment Site GitHub Blog
simulation

Facet

Domain Flow Simulation

Interactive visualization and simulation engine for domain flows. Consumes Moment's simulation scenarios (facet.json) to render event timelines, causation chains, crossing contracts, and branch paths — letting you test your domain model before writing implementation code.

Published Events

ScenarioLoadedFlowSimulatedCausationChainRenderedBranchPathValidated
Output: Interactive visualization

From the blog

The Candidate Lifecycle: When AI Models Your Domain, Who Confirms It?
Facet App Blog
downstream

Forge

Project System

Gets your project into motion. Consumes Moment's typed artifacts and simulation scenarios to bootstrap project structure, wire up bounded contexts, and establish the development workflow.

Output: Coming soon
Blog

The ComplaiEventEnvelope

Every event flowing between Sift, Moment, and Forge is wrapped in a canonical envelope. This shared format enables tools to consume each other's event streams without coupling to internal implementation details.

ComplaiEventEnvelope 
interface ComplaiEventEnvelope {
  eventId: UUID;              // Unique event identifier
  eventType: string;          // Discriminator for payload type
  version: string;            // Schema version (semver)
  productSource: string;      // Originating tool
  sessionId: UUID;            // Modeling session identifier
  causationEventIds: UUID[];  // Events that caused this event
  correlationId: UUID;        // Correlation chain identifier
  timestamp: ISO-8601;        // Event creation timestamp
  payload: object;            // Event-specific data
}

How events flow

sift moment

via Domain event streams

Sift publishes building block events that Moment imports as specification input

moment facet

via facet.json simulation scenarios

Moment generates Facet-compatible simulation scenarios with synthetic events, causation chains, and branch paths for visual validation

moment forge

via Typed artifacts + events

Moment produces typed artifacts and reconciliation events that Forge consumes to bootstrap project structure