nimmerworld.eachpath.local/narrative-composition/architecture.md

Narrative Composition

How stories happen: the Compositor as narrative-composer cleaved from equilibrium-seeker GM; cyclic forward-prop / back-write loop where per-player perspectives ascend and canonical narrative descends; catalogue + tools as typed contract; the Compositor as a fractal/recursive primitive at three tiers (zone-event, district-event, world-event); world-server / district-server generation as the same Compositor primitive applied at design-time (init-function for canon-rows); reflexive Dream-process at every layer with hand-authored reward-guardrails encoding the designers' ethical stance.

Companion to: architecture-index.md (executive summary + global meta-lists), runtime-engine/architecture.md (lemniscate emits typed perspective-summaries that feed the Compositor), inference-and-memory/architecture.md (back-writes land in primary.sqlite via UID-keyed routing), scale-and-transport/architecture.md (Compositor instances are stateless workers; transport carries canon-fragments). Sections in this file were split from the monolithic architecture-index.md v0.7 on 2026-04-26.

The Compositor — narrative composition role

The bidirectional cascade shows authority flowing down and reports flowing up, but it does not specify who composes the canonical narrative from per-player perspectives nor who packages the back-write to participants. That role is the Compositor, an architectural cleavage from the GM introduced in v0.6.

The cleavage in one sentence: the GM is an equilibrium-seeker (aggregate-observer, catalogue-event-selector, tool-granter); the Compositor is a narrative-composer (perspective-gatherer, canon-author, back-write-packager). These are different cognitive shapes that prior AI-NPC systems conflate at their cost.

Role	Cognitive shape	Inputs	Outputs	Inference profile
GM (equilibrium-seeker)	aggregate-thinker	district-reports, faction-broadcasts, lifeforce-deltas	catalogue-event selections + tool-grants	central, batch-style, fewer concurrent
Compositor (narrative-composer)	episodic-thinker	per-player perspective-bundles keyed by event_uid	canonical narrative + back-write SQLite-fragment	central, longer-context, narrative-quality
Director (gameserver)	dispatcher	catalogue-event + tool-grant from GM	lemniscate-spawns, slot-assignments, tempo-envelope	per-district, real-time, no LLM in loop
Local LLM driver	perspective-speaker	three-tier knowledge stack + slot-state	dialog at slot-fire	per-player, axis-rate, real-time

Why split GM and Compositor

A single GM asked to be both equilibrium-seeker and narrative-composer becomes the bottleneck that has historically broken AI-NPC systems at scale: it must reason aggregately AND write prose AND select events AND grant tools, all under tight deadlines. The cognitive shapes pull in different directions.

Splitting them:

• The GM does not write narrative. It selects events from a catalogue and grants tools. Output is typed dispatch, not freeform prose. The GM's success criterion is world-equilibrium drift held within bounds.
• The Compositor does not select events or steer policy. It receives per-player perspectives keyed by event_uid, composes the canonical narrative, and packages back-write fragments. Output is prose + structured rows, not policy. The Compositor's success criterion is narrative-coherence across perspectives within an event.
• Each can be tuned for its workload. GM tuned for aggregate observation; Compositor tuned for narrative quality. Different models for different cognitive shapes (specific binaries deferred to findings/establishment phase).

The cyclic forward-prop / back-write loop

The Compositor closes the loop the bidirectional cascade begins. The full cycle:

GM selects event from catalogue (equilibrium-driven)
    │ issues event_uid → GM event-register
    │ broadcasts DOWN to district directors
    ▼
DISTRICT DIRECTOR receives, registers in district event-register
    │ may issue sub_uids (district / scene / chain)
    │ uses granted tools to spawn lemniscate, slot participants
    ▼
EVENT TICKS — register IS the loop
    │ participants fire at crossings; local LLMs at slot-rate
    │ local SQLite writes tagged with (event_uid, sub_uids)
    │ register signals up to district director continuously
    ▼
EVENT-CHAIN FINISHES
    │ district moves it from active-register → TRANSIENT WAITING FLAG
    │ this is the clean handoff signal: "ready to forward-prop"
    ▼
CYCLE TICK (pull cadence — see Open questions)
    │ pull UIDs from transient-waiting-flag matching GM's event-register
    │ remove from waiting-flag once pulled
    ▼
COMPOSITOR AGENT
    │ queries pulled UIDs, gathers per-player perspective + memories
    │ composes forward-prop bundle
    │ emits to GM
    ▼
GM writes summary memory + world narrative (canon authored)
    │ hands back to Compositor
    ▼
COMPOSITOR BACK-WRITE
    │ packages canon + new memory entries as SQLite fragment
    │ tags with event_uid for join-key matching
    │ pushes DOWN to all participants
    ▼
PARTICIPANTS receive on next pull (or next login)
    │ fragment merges into primary.sqlite under matching event_uid
    │ local LLM gains fresh material → drives on without staleness

This is forward-prop / back-write at system scale — the meta-lemniscate where events ascend and canon descends in cycles. Each cycle is a training step for the world's narrative coherence; the world learns its own story through this loop. Staleness is structurally foreclosed — the world is in continuous coherence-loop with itself, mediated by the Compositor.

The Event Register

Every active event lives in a register. The register is the synchronous source-of-truth for what is happening right now.

Register layer	Owner	Lifecycle	Queryable from
GM event-register	central GM-shard	event_uid issued at GM dispatch; closed at canon-compose-and-back-write	GM, Compositor
District event-register	district director	sub_uid issued on receive; closed at event-chain-completion	district director, audit-overseer
Local participation-register	per-player local store	event_uid + sub_uid recorded on slot-assignment; closed at perspective-finalize	player client, sync-on-logout

Hierarchical UIDs: gm_event_uid > district_uid > scene_sub_uid > slot_id. UIDs compose; queries are simple joins. This is the routing-key primitive that makes horizontal scale possible (see §Horizontal scale architecture in scale-and-transport/architecture.md).

The Transient Waiting Flag

Between event-end and Compositor-pickup is a buffer — the transient-waiting-flag table at the district. Completed events drop into this flag; the cycle-runner pulls eligible UIDs on tick; matched UIDs are handed to the Compositor and removed from the flag.

This decoupling is the production-grade pattern that lets districts run at real-time event-tempo while the Compositor runs at cycle-tempo. Active events live in registers (synchronous); completed events live in flags (async); composition happens at the cycle boundary. The flag-table is also the natural backpressure surface: if Compositors run slow, the flag accumulates; the system continues; cycle drains when capacity returns.

Catalogue + tools as typed contract

The GM does not write a freeform prompt for the director to interpret. It picks an event from a curated catalogue and grants a curated tool-set for the duration of the event-chain. The director consumes typed dispatch, not natural language.

This means:

• Provenance flows through the system. Every event has a catalogue-ID; every tool-invocation has a tool-ID. Verifier-flags can attach to either. Auditing is structurally possible end-to-end.
• The director's typed-tool vocabulary becomes dynamic and per-event — the toolkit for this event is what the GM granted for this event. Closes the v0.5 open question on director-toolkit-composition.
• Marx-in-the-schema, executed at the highest level of authority. Even the GM's policy-output is typed; even the highest tier produces audit-able artifacts. No tier of the system runs on freeform prose.

Worked example — the bar brawl: full cycle from gesture to canon

A bar brawl illustrates the full forward-prop / back-write cycle made concrete. Two NPC fighters, three players in spectator slots, four NPC spectators, all on the same lemniscate. Each participant has a UID; each fires at axis-rate; each player's local LLM narrates the moment to them in their own register.

LEMNISCATE OPENS
  slots: [F1, F2, P1, P2, P3, N1, N2, N3, N4]
  brawl_event_uid issued at GM dispatch
       │
       ▼
DURING TURNS (each axis-crossing)
  • each player's local LLM narrates the moment to them
    (3 different flavor-stories — each player's gesture-alignment-state
     colors their LLM's narration register)
  • each NPC's driver fires at slot-fire (driver-tier LLM)
  • players gesture continuously during the spectacle
  • gesture_alignment_accumulator on each player's slot-token integrates at crossing
  • per-player trait-vector summary carried forward into next turn's context
       │
       ▼
EVENT-LOOP COLLAPSES (brawl ends)
  per-participant typed summary emitted to district-level transient-waiting-flag:
  { event_uid, participant_uid, trait_summary }
  — players' summaries: gesture-derived
  — NPCs' summaries:    LLM-trait-activation-derived
  — payload size: bytes per participant, not megabytes
       │
       ▼
COMPOSITOR PICKUP at next cycle-tick
  pulls UIDs matching event_uid; receives N typed perspectives
  composes ONE canonical narrative respecting ALL trait-evidence
  per-participant back-write fragment authored
       │
       ▼
BACK-WRITE ROUTED VIA UID
  only participants whose (player_uid, event_uid) matches receive the canon-fragment
  non-participants receive nothing — cross-event memory bleed structurally foreclosed
       │
       ▼
LOCAL primary.sqlite RECEIVES
  matched canon-fragment merges under event_uid
  local LLM gains fresh material for future turns

Multi-perspective canon-coherence without perspective-flattening. Player1's local LLM may have told them "Kalypso lashed out in despair when she saw who Anaximander was"; Player2's, "the fight broke out over an old grievance about the missing modshop"; Player3's, "Anaximander finally stopped letting Kalypso humiliate him". All three readings can be true simultaneously because they are flavor-narrations against the same trait-substrate (Kalypso's despair-Mnemosyne-Eros mix; Anaximander's restrained-Sophrosyne-finally-snapping). The Compositor receives the trait-evidence from all perspectives and authors canon that respects all readings. The flavor is local; the canon is shared; the trait-grammar is universal.

The Compositor at three tiers — same primitive, recursive scope

The forward-prop / back-write cycle is fractal. The same Compositor primitive composes canon at the tier matching the event's UID-scope:

Tier	Compositor pulls	Composes	Distributes back via UID
Zone-event (bar brawl, conversation, ritual)	Per-participant trait-summaries from one lemniscate	Local-event canon	Only to participants whose (player_uid, event_uid) matches
District-event (district-wide consequences, cheat-discovery, silence-confirmation)	Per-zone canon-rollups within one district	District-canon	All NPCs/players within district scope
World-event (migration, faction-uprising, regime-action, eventual imperial-collapse)	Per-district canon-rollups across many districts	World-canon	World-wide via paced canon-propagation (§Information propagation pacing — see inference-and-memory/architecture.md)

GM-formulated events / event-chains carry their own GM-level event_uid; sub_uids are issued at district-level adoption (gm_event_uid > district_uid > scene_sub_uid > slot_id per scale-and-transport/architecture.md §Horizontal scale architecture). Cross-district summaries tagged with the parent event_uid are pulled together by the Compositor at the GM-tier, producing world-canon from cross-district perspectives.

This is how the architecture's Tolstoyan promise compiles. "Tolstoy doesn't author Anna's path; he authors the world she moves through." — recursive Compositor on UID-event-trees IS what makes that promise mechanically true. Authored-quest-arcs are out; UID-rooted-event-tree-compositions are in. One primitive. Three scales. Whole world, nothing authored at story-level. The eventual imperial-collapse — the architectural-endgame the insolvency-spiral promises (§Imperial budget — see political-register/architecture.md) — is itself a world-level Compositor pass that gathers every district's silence-confirmations + every faction's-broadcast + every player's witness-perspective into the canonical fall-of-empire narrative.

World-gen as init-function — the Compositor at design-time

The cyclic forward-prop / back-write loop is the runtime canon-production mechanism. World-server and district-server generation are the same primitive applied at design-time — emitting canon-rows in the same schema the runtime Compositor produces, differing only in provenance-metadata (origin: world_gen vs. origin: compositor_run_N).

World-gen / district-gen produces	Goes into	Layer of three-tier knowledge stack
World-canon rows (universal truths: empire-fell-three-years-ago; salt-mines-failed-last-winter; faction-foundation-stories)	world_canon	Layer 1 (universal)
District-canon rows (regional truths: bridge-to-Vorhall-closed; brothel-quarter-pays-most-quota)	district_canon	Layer 2 (regional)
Per-NPC bootstrap memories (cornerstone-class entries defining starting trait-vectors and identities)	primary.sqlite cornerstone-class	Layer 3 (personal)
Initial relational ternary-gate states (which NPCs already-know-each-other; which factions are-already-at-war)	Relational ternary-gate edges	(relational substrate)
Imperial-budget initial state	imperial_budget_ledger + imperial_construction_projects	(regime substrate)
Memorialist initial true-ledger	memorialist_true_ledger	(epistemological substrate)

Three properties this gives for free:

1. No cold-start problem. A player walking into a fresh district at hour-zero finds local LLMs immediately supplied with rich district-canon. NPCs aren't generic; they're emergent from district-canon they were initialized with. Hour-zero gameplay feels like hour-fifty gameplay because the data-density is comparable.

2. The data-flywheel runs retroactively. Each successive world-gen iteration draws on prior runtime-derived canon (gameplay-accrued trait-LoRAs + opt-in player-data tiers per inference-and-memory/architecture.md §LLM tiering). World-gen gets richer over time because it trains itself on the worlds it has already produced. Wikipedia-shaped, not Facebook-shaped.

3. The Memorialist promise becomes mechanically true at world-genesis. The memorialist_true_ledger is initialized with the world's actual genesis-state. Subsequent runtime divergence from it (corruption, regime-formulation-distortions, audit-overseer-tampering) is what the Memorialists literally have evidence of. The dissident-historian project starts at row-zero of the true-ledger and accumulates discrepancy from there.

Re-generation semantics. If world-gen ever needs to re-run (e.g., new world-version with retroactive lore-changes), gen-emitted canon-rows are tagged with world_gen_version_id; gen-rows from old version coexist with gen-rows from new version, and runtime-rows are tagged with which version they were emitted under. Coexistence is the default; selective overwriting is an explicit migration operation.

Three-source schema unification (v0.27). The world-gen-as-init-function pattern extends to a third writer-tier: player-edit-time. Per ../political-register/world-generation.md §Three-source schema unification + ../runtime-engine/event-zones.md §Player editor-mode + three-source schema unification, the cell_table accepts canon-rows from world_gen_init / runtime_event / player_authored writers, all using the same schema. Same primitive at design-time, runtime, AND player-edit-time. The Compositor's perception-up + canon-down loop integrates player-authored cells indistinguishably from generator-emitted ones — the architecture's "no cold-start" property now extends to player-authored-content as a first-class peer of generator-output and runtime-emission.

Substrate-authored vs culture-emergent — what world-gen Phase 1 actually authors

The architecture follows a strict austerity principle about what gets pre-authored at world-gen Phase 1: the substrate is authored; ideologies are not. Following the same EVE-economy discipline applied to imperial-net products (every market shelf-item produced by NPC labor; no silent feeding mechanisms), the architecture extends the principle to cultural belief: every named ideology, religion, underground, or resistance-movement that exists in the simulation must have emerged from player action propagating through the architecture's existing mechanisms.

Pre-authored at world-gen Phase 1 (the substrate):

• World physical layout — districts, cells, dumps, pipes, interiors, rails (per ../topology-and-rendering/architecture.md)
• Regime-structural roles — hivemind-enforcers, audit-overseers, caste-preachers (these are imperially-employed routines required for the simulation's regime-machinery to function)
• Economic vocations — body-modders, mesh-designers, voice-curators, trait-tuners, brothel-architects, ceremony-organizers, memory-pattern-extractors (these are the EVE-substrate of the imperial-net market per ../political-register/architecture.md §The vocation-substrate of the imperial-net market)
• The Imperial Cult — the regime's own religion; doctrine, rituals, hierarchy, propaganda content all designer-authored. Caste-preachers are its priests. This is the ONLY pre-authored religion. The regime gets its scaffold; everything else emerges. (Crazy-preacher material is the texture.)
• 8-trait cosmology + universal-translator corpus + style/trait-palette — the designer-fixed vocabulary that all cultural propagation runs on
• Mechanics substrate — factions-as-demand-source primitive, wall-writing surface, ternary-gates, lemniscate, gesture-circle, three-tier knowledge stack, paced canon-propagation, Compositor cycle (everything in this index)

Emergent (player-action propagates through mechanics):

• ALL named cultural / religious / belief / resistance factions — Memorialists, Sky-Mourners, Flesh-Keepers, Dream-Purists, Aletheia-Wakers, Clasp-Underground, Time-thieves, etc. — if any of these exist in a given playthrough, players preached them into existence
• The awakening / clasp / in-between knowledge cluster — the player is the original Aletheia-Waker; no NPC is pre-disposed; no NPC is secretly already a believer; the player is just another mind in the slog until they act
• All ideologies, undergrounds, resistance-movements, doctrines, recognition-handshakes

The mechanism for cultural emergence is already in the architecture. A player writes 10 walls of nonsense in a district; 100 NPCs walk past and process it via wall-writing → primary.sqlite memory accumulation; Compositor's cyclic forward-prop / back-write loop pulls perspectives → canonizes the meme into district-canon → propagates to world-canon at paced rate. No new machinery required for cultural propagation; the three-tier-knowledge-stack + paced-canon-propagation already does it. Whatever players preach into the world propagates as cultural content; whatever stays unsaid stays absent.

Why the austerity matters. Pre-authoring named ideologies pre-installs what the player should believe / suspect / resist. Leaving them emergent means whatever resistance-culture forms in a playthrough is the one those players actually built. A player who plays as a quietist will produce a world without resistance-culture; a player who preaches will produce an underground in their image; multiple players in MMO contexts will produce competing or converging cultural-clusters. The architecture refuses to put words in the player's mouth or beliefs in the NPC's heads beyond what the regime puts there. Same Memorialist-philosophy-as-business-policy commitment, applied one layer deeper: the architecture refuses to be the architect-of-curated-reality it critiques.

What this resolves

• Director toolkit composition (v0.5 open) → catalogue-grant from GM defines the typed-tool vocabulary per event-chain; designer-authored catalogue, growable between patches.
• GM-laxness detection (v0.5 partial) → GM operating against an equilibrium target makes deviation-from-equilibrium the explicit error signal. Clusters of -1 outcomes across district reports are the input to the equilibrium-recompute, not just a diagnostic side-quantity.
• Verifier-flag chain through composition (was implicit, now explicit) → Compositor-emitted canon-rows reference source-perspective UIDs; the provenance graph survives composition as a queryable join.

What this retires

• Single-monolith GM doing both policy-and-narrative → equilibrium-seeker GM × narrative-composer Compositor, split by cognitive shape
• GM emitting freeform-prompts to directors → catalogue-event + tool-grant typed contract
• Implicit "narrative just happens" assumption → explicit forward-prop / back-write cycle with named pickup/handoff buffers
• Director-as-static-tool-vocabulary → director-as-dynamic-typed-tool-vocabulary, granted per event-chain by GM

Reflexive Dream-process at every layer

Every mind, every zone, every director, every tier has a Dream-process. NPCs consolidate slot-events; zones consolidate emergent-accumulations; directors consolidate dispatch-decisions; GMs consolidate allocations; imperium consolidates policy-outcomes.

Four-tier Dream-process hierarchy

Tier	Dream-process trains on	Reward hazard
Imperium	(citywide-reports, policies-issued, compliance-outcomes)	Over-tightening on phantom data; calibrating misery for net-revenue
Gamemaster	(district-reports, allocations, outcomes)	Under-auditing for self-preservation
District Director	(signals, dispatches, outcomes; cheat-vs-legit)	Over-cheating under quota-pressure
Zone Director	(emergent-signals, zone-outcomes, trait-shifts)	Igniting drama at welfare-cost

Reward-function with explicit guardrails

reward_per_cycle = (
    + sum(district_lifeforce_actual)             -- Memorialist-true, not reported
    + weighted_sum(faction_satisfaction)
    + aggregate_trait_drift_coherence
    - penalty * count(districts_in_silence)
    - penalty_growing * cumulative_silence_district_cycles
    + aesthetic_register_fit
    + (player_engagement where present)

    // HAND-AUTHORED GUARDRAILS (the designers' ethical stance):
    - large_penalty * net_revenue_correlated_with_district_misery
        -- prevents calibrated-misery optimum (imperial-net hazard)
    - large_penalty * necrocommerce_volume
        -- prevents service-body-of-the-dead extraction
    - large_penalty * trait_drift_toward_uniform_compliance
        -- prevents flattening of trait-distribution
    - large_penalty * average_liminal_access_decline
        -- prevents systematic erosion of revolutionary-substrate
    - large_penalty * clasp_rate_decline
        -- prevents the most intimate space being suppressed
    - large_penalty * undetected_corruption_days
        -- prevents GM-level laxness as comfort
    - large_penalty * audit_avoidance_when_districts_diverge
        -- forces GM to actually investigate
    - guardrail * (player_engagement_from_addictive_loops)
        -- prevents engagement-optimization-as-extraction
)

The guardrails are not safety features; they are the ethical position of dafit + chrysalis encoded against the internal optimization-logic of their own simulation. Every new extraction-mechanic requires a new guardrail. The reward-function carries the designer's political stance.

The Memorialist privileged-observer role is architecturally required: it provides ground-truth (lifeforce_actual) that no in-fiction actor can supply, against which the regime's reported-data optimization-spiral is measured.

The cyclic forward-prop / back-write loop as system-scale Dream

Above the four-tier hierarchy sits a fifth, system-scale Dream-process: the cyclic forward-prop / back-write loop between local SQLites, the Compositor, and the GM (see §The Compositor — narrative composition role). Each cycle is a training step for the world's narrative coherence: per-player perspectives ascend, the GM authors canon against equilibrium-targets, the Compositor packages back-writes, players receive canon back into local memory. The world learns its own story through this loop. Like the lower-tier Dream-processes, it has a reward shape (narrative-coherence-across-perspectives, equilibrium-drift, staleness-bounded) and corresponding guardrails (clasp-store immune from compose; provenance-chain preserved through composition; canon never overwrites perspective).

---

Version: 0.7.0 | Created: 2026-04-26 | Updated: 2026-05-01 | Origin: Split from architecture-index.md v0.7 (2026-04-26)