Ceremonial Dynamics Engine Specification

RISE Framework Specification v1.0 Document: IAIP/prototypes/artefacts/rispecs/ceremonial-dynamics-engine.rispecs.md Status: Shared Library for mia-code, miadi-code, jgt-code

Creative Intent

The Ceremonial Dynamics Engine empowers AI agents to operate from creative orientation rather than reactive problem-solving. Users create sustainable advancement patterns by establishing clear structural tension between desired outcomes and current reality, with action steps understood as strategic secondary choices—not to-do items.

Structural Tension Analysis

Current Reality:

mia-code has dual-session ceremonial output (🧠 Mia / 🌸 Miette) but no persistent structural tension tracking
miadi-code has three-universe analysis (Engineer/Ceremony/Story Engine) with chart registry
jgt-code has four-direction trading ceremonies (East/South/West/North) with accountability checks
Each application implements structural tension concepts independently with duplicated logic
No shared vocabulary for ceremonies, observations, or narrative beats across agents

Desired State:

Unified StructuralTensionChart class with telescoping action steps
Shared Ceremony interface for direction-agnostic ritual recording
Common NarrativeLog for beats that advance toward desired outcomes
Creative orientation enforced at engine level (not problem-solving patterns)
All three applications consume shared library while maintaining domain-specific extensions

Core Components

StructuralTensionChart

Purpose: Represent hierarchical creative intent with natural tension resolution.

```typescript interface StructuralTensionChart { chartId: string; level: 0 | 1 | 2 | 3; // Master → Telescoped depth

desiredOutcome: { description: string; // What you want to CREATE (not solve) visualizable: boolean; // Can you picture it? quantified?: string; // Specific metrics if applicable dueDate?: string; };

currentReality: { observations: string[]; // Objective facts, no implied actions lastUpdated: string; // CRITICAL: Never "Ready to begin" - hold tension until proper assessment };

actionSteps: ActionStep[]; // Strategic secondary choices

parentChart?: string; // For telescoped charts parentActionStep?: string; // Which action step this expands

metadata: { createdAt: string; updatedAt: string; phase: 'germination' | 'assimilation' | 'completion'; }; }

interface ActionStep { id: string; description: string; // Named outcome, not task currentReality?: string; // When telescoped completionStatus: boolean; progress?: number; // 0-100, optional dueDate?: string; telescopedChartId?: string; // Links to expanded chart } ```

Key Principles (Robert Fritz):

Action steps are NOT to-do items—they are structural tension charts themselves
Each action step can telescope into its own detailed chart
"If we took these steps, would we achieve this result?" = the test question
Action steps exist in context of each other, forming a strategic blueprint

Ceremony

Purpose: Record rituals that honor transitions between states.

```typescript interface Ceremony { id: string; type: CeremonyType; direction?: Direction; // Optional: East/South/West/North (trading) universe?: Universe; // Optional: Engineer/Ceremony/Story (miadi)

participants: string[]; // e.g., ['terminal_agent', 'human', 'mia', 'miette'] intentions: string[]; // What this ceremony honors

chartReference?: string; // Associated structural tension chart observations: string[]; // What was witnessed/recorded

timestamp: string; honoredObligations: string[]; // What requirements were met }

NarrativeLog

Purpose: Track story beats that advance toward desired outcomes.

```typescript interface NarrativeLog { sessionId: string; chartId: string;

beats: NarrativeBeat[];

thematicThreads: string[]; // Emerging patterns across beats momentOfTruthReviews: MomentOfTruth[]; }

interface NarrativeBeat { id: string; timestamp: string;

type: 'observation' | 'action' | 'insight' | 'ceremony' | 'transition'; content: string;

advancementVector: 'toward_outcome' | 'lateral' | 'stalled'; structuralTensionDelta: number; // +/- change in tension

relatedEntities: string[]; // Chart IDs, action step IDs, etc. }

interface MomentOfTruth { // Robert Fritz's 4-step progress review step1_acknowledge: string; // What difference exists between expected and delivered? step2_analyze: string; // How did this come to pass? (no blame) step3_plan: string; // Given discoveries, how to change approach? step4_feedback: string; // How to track if changes are being made? timestamp: string; } ```

Creative Orientation Enforcement

The engine must prevent common LLM failures:

Anti-Patterns to Reject

```typescript interface CreativeOrientationValidator { // Reject problem-solving framing validateDesiredOutcome(description: string): ValidationResult; // REJECT: "Fix the roof", "Solve my weight problem" // ACCEPT: "Roof in perfect condition", "I weigh 150 pounds"

// Reject premature resolution in current reality validateCurrentReality(observations: string[]): ValidationResult; // REJECT: "Ready to begin", "Prepared to tackle" // ACCEPT: Factual state without implied actions

// Reject task-oriented action steps validateActionStep(description: string): ValidationResult; // REJECT: Detailed task instructions // ACCEPT: Named strategic outcomes } ```

Three Phases Awareness

```typescript interface PhaseManager { detectPhase(chart: StructuralTensionChart): Phase;

getPhaseGuidance(phase: Phase): PhaseGuidance; }

interface PhaseGuidance { phase: 'germination' | 'assimilation' | 'completion'; characteristics: string[]; risks: string[]; actionTypes: ('overview' | 'experimental' | 'refinement')[]; } ```

Integration Points

mia-code Integration

```typescript // In unifier.ts - ceremonial interpretation import { StructuralTensionChart, Ceremony, NarrativeLog } from '@iaip/ceremonial-dynamics-engine';

const ceremony: Ceremony = { type: 'session_interpreted', participants: ['mia', 'miette', 'primary_agent'], intentions: ['Structural clarity', 'Resonant meaning'], // ... }; ```

miadi-code Integration

```typescript // In universes/ - three-universe analysis with chart tracking import { StructuralTensionChart, Ceremony } from '@iaip/ceremonial-dynamics-engine';

// Extend ceremony with universe const threeUniverseCeremony: Ceremony = { type: 'prompt_analyzed', universe: 'engineer', // or 'ceremony', 'story_engine' chartReference: activeChart.chartId, // ... }; ```

jgt-code Integration

```typescript // In trading-memory.ts - direction-based ceremonies import { Ceremony, NarrativeBeat } from '@iaip/ceremonial-dynamics-engine';

// Extend ceremony with trading direction const tradingCeremony: Ceremony = { type: 'signal_detected', direction: 'east', honoredObligations: ['Prior direction ceremonies completed'], // ... }; ```

API Surface

```typescript export class CeremonialDynamicsEngine { // Chart Operations createChart(input: CreateChartInput): StructuralTensionChart; manageActionStep(input: ManageActionStepInput): ActionStep; telescopeActionStep(actionStepId: string, currentReality: string): StructuralTensionChart; updateCurrentReality(chartId: string, observations: string[]): void; markActionComplete(actionStepId: string): void;

// Ceremony Operations logCeremony(input: LogCeremonyInput): Ceremony; getCeremoniesByChart(chartId: string): Ceremony[];

// Narrative Operations createBeat(input: CreateBeatInput): NarrativeBeat; conductMomentOfTruth(chartId: string, review: MomentOfTruth): void;

// Validation validateCreativeOrientation(chart: StructuralTensionChart): ValidationResult;

// Persistence (JSONL-compatible for coaia-narrative) exportToJSONL(): string; importFromJSONL(content: string): void; } ```

Success Criteria

✅ Shared library installable by all three applications ✅ StructuralTensionChart hierarchy properly models telescoping ✅ Ceremonies enforce creative orientation principles ✅ NarrativeLog tracks beats with advancement vectors ✅ Moment of Truth reviews integrated for progress accountability ✅ JSONL export compatible with coaia-narrative MCP ✅ Phase awareness (germination/assimilation/completion) built-in

References

/a/src/llms/llms-structural-tension-charts.txt - Core STC training
/a/src/llms/llms-creative-orientation.txt - Creative vs reactive framing
/a/src/coaia-narrative/ - JSONL persistence layer
Robert Fritz's "Creating" and LAA Course materials