first draft ofthe lemniscate

runtime-engine/LEMNISCATE-RUNTIME-Pseudo-code-001.py

@@ -0,0 +1,423 @@
+# LEMNISCATE RUNTIME - Pseudo-code Implementation
+# Companion to runtime-engine/architecture.md
+
+from enum import Enum, auto
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Set, Callable
+from abc import ABC, abstractmethod
+import math
+
+# ============================================================================
+# CORE PRIMITIVES - The shape of flow
+# ============================================================================
+
+class SlotState(Enum):
+    """State of a slot in the lemniscate"""
+    EMPTY = auto()
+    OCCUPIED = auto()
+    EXITING = auto()
+
+@dataclass
+class VerifierFlags:
+    """Marker bits carried by slot-tokens, read at crossing"""
+    exit_eligible: bool = False
+    has_spoken_this_roundtrip: bool = False
+    mid_action: bool = False
+    goal_satisfied: bool = False
+    silence_eligible: bool = False
+    priority_pull: bool = False
+
+    def clear_transient(self):
+        """Clear flags that reset each crossing"""
+        self.has_spoken_this_roundtrip = False
+        self.silence_eligible = False
+
+@dataclass
+class SlotToken:
+    """A token carried around the loop - represents an NPC in the zone"""
+    npc_id: str
+    state: SlotState = SlotState.OCCUPIED
+    flags: VerifierFlags = field(default_factory=VerifierFlags)
+    # Accumulator for gesture alignment (recursive lemniscate)
+    gesture_alignment_accumulator: Dict[str, float] = field(default_factory=dict)
+
+    def add_gesture_alignment(self, trait: str, value: float):
+        """Add a gesture/trait value to the accumulator"""
+        self.gesture_alignment_accumulator[trait] = \
+            self.gesture_alignment_accumulator.get(trait, 0.0) + value
+
+# ============================================================================
+# THE LEMNISCATE - Geometry as clock
+# ============================================================================
+
+class Lemniscate:
+    """
+    The core runtime topology - a through-flow figure-eight.
+    Traversal IS the turn order.
+    """
+
+    def __init__(self, n_slots: int):
+        self.n_slots = n_slots
+        self.slots: List[Optional[SlotToken]] = [None] * n_slots
+
+        # The cursor - position on the lemniscate
+        # (loop_id, slot_index) - loop 0 = A, loop 1 = B
+        self.cursor_loop: int = 0
+        self.cursor_slot: int = 0
+
+        # Entry and exit queues
+        self.entry_line: List[SlotToken] = []
+        self.exit_line: List[SlotToken] = []
+
+        # The crossing is the ONLY synchronous event
+        self.crossing_callbacks: List[Callable] = []
+
+    def advance_cursor(self) -> bool:
+        """
+        Advance cursor through the lemniscate.
+        Returns True if we reached the crossing.
+        """
+        self.cursor_slot += 1
+
+        # Completed one loop
+        if self.cursor_slot >= self.n_slots:
+            self.cursor_slot = 0
+            self.cursor_loop = 1 - self.cursor_loop  # Toggle A/B
+            return True  # Reached crossing
+
+        return False
+
+    def at_crossing(self) -> bool:
+        """Cursor is between loops - at the synchronous crossing point"""
+        return self.cursor_slot == 0
+
+    def get_active_token(self) -> Optional[SlotToken]:
+        """Get token at current cursor position"""
+        if self.cursor_slot < len(self.slots):
+            return self.slots[self.cursor_slot]
+        return None
+
+    def register_crossing_callback(self, callback: Callable):
+        """Register a function to run at each crossing"""
+        self.crossing_callbacks.append(callback)
+
+    def trigger_crossing(self):
+        """
+        The crossing event - all state updates resolve atomically.
+        This is the ONLY time the zone touches the global state bus.
+        """
+        # 1. Run all registered callbacks (dialog turns, state updates)
+        for callback in self.crossing_callbacks:
+            callback()
+
+        # 2. Process exit-eligible tokens
+        self._process_exits()
+
+        # 3. Push from entry line to fill vacancies
+        self._process_entries()
+
+        # 4. Clear transient flags
+        self._clear_transient_flags()
+
+    def _process_exits(self):
+        """Route exit-eligible tokens to exit line"""
+        for i, token in enumerate(self.slots):
+            if token and token.flags.exit_eligible:
+                self.exit_line.append(token)
+                self.slots[i] = None
+                token.state = SlotState.EXITING
+
+    def _process_entries(self):
+        """Fill vacant slots from entry line"""
+        for i, slot in enumerate(self.slots):
+            if slot is None and self.entry_line:
+                self.slots[i] = self.entry_line.pop(0)
+
+    def _clear_transient_flags(self):
+        """Clear flags that reset each crossing"""
+        for token in self.slots:
+            if token:
+                token.flags.clear_transient()
+
+# ============================================================================
+# ZONES - Bounded places of structured speaking
+# ============================================================================
+
+class ZoneRegister(Enum):
+    """Which ontological register this zone lives in"""
+    PHYSICAL = auto()
+    LIMINAL = auto()
+    IMPERIAL = auto()
+
+class Zone:
+    """
+    A bounded, named, slot-indexed, director-managed event instance.
+    The zone IS the lemniscate, not a container for it.
+    """
+
+    def __init__(self, name: str, n_slots: int, register: ZoneRegister = ZoneRegister.PHYSICAL):
+        self.name = name
+        self.register = register
+        self.lemniscate = Lemniscate(n_slots)
+
+        # Purpose - spawn intent, immutable
+        self.purpose: str = ""
+
+        # State tracking
+        self.scene_state_public: Dict = {}
+        self.ternary_gate_edges: Dict[tuple, str] = {}  # (npc_id, npc_id) -> CLOSED/STABLE/OPEN
+        self.drift_state: Optional[str] = None  # Delta from spawn intent
+
+        # Lifeforce binding
+        self.lifeforce_budget: float = 0.0
+        self.lifeforce_burned: float = 0.0
+        self.pulse_rate: float = 1.0  # Crossings per second
+
+        # Lifecycle
+        self.is_terminated: bool = False
+        self.crossing_count: int = 0
+
+        # Player gesture overlay - broadcasts to all active slots
+        self.pending_gestures: List[tuple] = []  # (trait, value)
+
+    def set_purpose(self, purpose: str):
+        """Set the zone's spawn intent - immutable after this"""
+        self.purpose = purpose
+
+    def add_npc(self, npc_id: str, traits: Dict[str, float]):
+        """Add an NPC to the entry line"""
+        token = SlotToken(npc_id=npc_id)
+        for trait, value in traits.items():
+            token.gesture_alignment_accumulator[trait] = value
+        self.lemniscate.entry_line.append(token)
+
+    def add_gesture(self, trait: str, value: float):
+        """
+        Add a player gesture to the accumulator.
+        These integrate at the next crossing.
+        """
+        self.pending_gestures.append((trait, value))
+
+    def broadcast_gestures_to_active(self):
+        """
+        Phase-locked overlay broadcast - all active slots perceive
+        the same player gesture simultaneously.
+        """
+        for token in self.lemniscate.slots:
+            if token:
+                for trait, value in self.pending_gestures:
+                    token.add_gesture_alignment(trait, value)
+        self.pending_gestures.clear()
+
+    def run_crossing(self):
+        """Execute one axis crossing - the core unit of zone time"""
+        self.crossing_count += 1
+
+        # Broadcast player gestures before the crossing
+        self.broadcast_gestures_to_active()
+
+        # Trigger the crossing - all state updates resolve atomically
+        self.lemniscate.trigger_crossing()
+
+        # Lifeforce burn
+        active_slots = sum(1 for t in self.lemniscate.slots if t is not None)
+        self.lifeforce_burned += self.pulse_rate * active_slots
+
+        # Check for termination
+        if self.lifeforce_burned >= self.lifeforce_budget:
+            self.terminal_report("budget_exhausted")
+            self.is_terminated = True
+            return
+
+        # Empty queue behavior: shrink at every crossing
+        if len(self.lemniscate.entry_line) == 0:
+            self._shrink()
+
+        # Check if zone has dissolved
+        if all(t is None for t in self.lemniscate.slots):
+            self.terminal_report("dissolved")
+            self.is_terminated = True
+
+    def _shrink(self):
+        """Dissolve one active slot when entry line is empty"""
+        # Find last occupied slot
+        for i in range(len(self.lemniscate.slots) - 1, -1, -1):
+            if self.lemniscate.slots[i] is not None:
+                self.lemniscate.exit_line.append(self.lemniscate.slots[i])
+                self.lemniscate.slots[i] = None
+                break
+
+    def terminal_report(self, reason: str) -> Dict:
+        """Generate the report sent back to spawning director"""
+        participants = [t.npc_id for t in self.lemniscate.slots if t is not None]
+        return {
+            "name": self.name,
+            "purpose": self.purpose,
+            "reason": reason,
+            "crossings": self.crossing_count,
+            "lifeforce_cost": self.lifeforce_burned,
+            "participants": participants,
+            "drift": self.drift_state
+        }
+
+# ============================================================================
+# TWO-LAYER EXECUTION - State machine + lemniscate
+# ============================================================================
+
+class StateMachineLayer:
+    """
+    Physical action layer - runs at simulation tick (fast).
+    Decoupled from lemniscate cursor.
+    """
+
+    def __init__(self):
+        self.actions: Dict[str, Callable] = {}
+        self.state: Dict[str, Any] = {}
+
+    def register_action(self, name: str, callback: Callable):
+        """Register a physical action"""
+        self.actions[name] = callback
+
+    def execute(self, npc_id: str, action_name: str):
+        """Execute a physical action for an NPC"""
+        if action_name in self.actions:
+            self.actions[action_name](npc_id, self.state)
+
+    def get_status(self) -> Dict:
+        """Snapshot of physical state for dialog layer"""
+        return self.state.copy()
+
+class EmergentZone(Zone):
+    """
+    A dramatic episode unit with goal evaluation.
+    """
+
+    def __init__(self, name: str, n_slots: int, purpose: str,
+                 goal: Dict, budget: float):
+        super().__init__(name, n_slots)
+        self.set_purpose(purpose)
+        self.goal = goal
+        self.lifeforce_budget = budget
+
+        # Two-layer execution
+        self.state_machine = StateMachineLayer()
+        self.dialog_layer = self  # Zone IS the dialog layer
+
+        # Goal tracking
+        self.goal_satisfied = None
+        self.goal_axis: str = ""
+
+    def execute_turn(self, dt: float):
+        """
+        Execute both layers in synchronized-but-loose harmony.
+        Speech doesn't gate action; action doesn't block speech.
+        """
+        # State machine layer (fast, at sim tick)
+        for action in self.state_machine.actions:
+            # Execute physical actions
+            pass
+
+        # Dialog layer (at axis rate)
+        if self._should_crossing(dt):
+            self.run_crossing()
+            self._evaluate_goal()
+
+    def _should_crossing(self, dt: float) -> bool:
+        """Determine if axis crossing should occur based on pulse rate"""
+        # Simplified - would track cumulative time in real impl
+        return dt >= (1.0 / self.pulse_rate)
+
+    def _evaluate_goal(self):
+        """Ternary evaluation against trait axis"""
+        if self.goal.get("type") == "numeric":
+            # Simple threshold
+            threshold = self.goal["threshold"]
+            # Would check state machine variable
+            self.goal_satisfied = 1 if True else 0
+        elif self.goal.get("type") == "fuzzy":
+            # Trait-axis ternary evaluation
+            axis = self.goal["axis"]
+            # Would evaluate ternary gate state delta
+            self.goal_satisfied = 0  # +1 / 0 / -1
+            self.goal_axis = axis
+
+# ============================================================================
+# DISTRIBUTED FUNDING - Director + participant lifeforce
+# ============================================================================
+
+class Director:
+    """
+    Manages zones for a region. Owns spawn decisions and budget.
+    """
+
+    def __init__(self, region: str, budget: float):
+        self.region = region
+        self.lifeforce_budget = budget
+        self.active_zones: Dict[str, Zone] = {}
+
+    def spawn_zone(self, name: str, purpose: str, slots: int,
+                   budget: float, params: Dict = {}) -> Zone:
+        """
+        Spawn a new zone - pays spawn cost from own budget.
+        """
+        zone = EmergentZone(name, slots, purpose, params.get("goal", {}), budget)
+        zone.lifeforce_budget = budget
+        self.lifeforce_budget -= budget  # Director pays spawn cost
+        self.active_zones[name] = zone
+        return zone
+
+    def update_all_zones(self, dt: float):
+        """Advance all active zones"""
+        for zone in list(self.active_zones.values()):
+            if not zone.is_terminated:
+                zone.run_crossing()
+                # Would collect terminal reports
+
+
+# ============================================================================
+# EXAMPLE: A rescue emergent zone
+# ============================================================================
+
+def example_rescue_zone_setup():
+    """
+    Demonstrates the rescue event pattern from the architecture.
+    """
+
+    # Director has a budget
+    director = Director("district_1", budget=1000.0)
+
+    # NPC A's limb is broken - emergent signal
+    # Director consumes signal and spawns rescue event
+
+    rescue_goal = {
+        "type": "numeric",
+        "threshold": 10.0,  # limb_A >= 10%
+        "fallback": {
+            "type": "fuzzy",
+            "axis": "Sophrosyne",
+            "direction": "positive"
+        }
+    }
+
+    rescue = director.spawn_zone(
+        name="rescue_in_marketplace",
+        purpose="medical_emergency",
+        slots=4,
+        budget=50.0,
+        params={"goal": rescue_goal}
+    )
+
+    # Add NPCs who might help
+    rescue.add_npc("npc_patient", {"Philotes": 0.3, "Sophrosyne": 0.1})
+    rescue.add_npc("npc_bystander_1", {"Philotes": 0.7, "Sophrosyne": 0.5})
+    rescue.add_npc("npc_bystander_2", {"Philotes": 0.2, "Sophrosyne": 0.8})
+
+    # Player adds a gesture (helping)
+    rescue.add_gesture("Philotes", 0.8)
+
+    # Runtime tick
+    rescue.execute_turn(0.016)  # 60fps
+
+
+if __name__ == "__main__":
+    example_rescue_zone_setup()