From 78c84726ff389ce42ee6d2cea8163c680295a993 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Mon, 15 Jun 2026 02:36:28 +0100 Subject: [PATCH] Add cinematic pipeline to daemon swarm docs --- docs/daemonic-swarm-prior-work.md | 50 ++++++++++++++++++++ docs/gamecult-daemonic-swarm.md | 78 ++++++++++++++++++++++++++++++- state/evidence.jsonl | 1 + 3 files changed, 128 insertions(+), 1 deletion(-) diff --git a/docs/daemonic-swarm-prior-work.md b/docs/daemonic-swarm-prior-work.md index e55effa..6049178 100644 --- a/docs/daemonic-swarm-prior-work.md +++ b/docs/daemonic-swarm-prior-work.md @@ -54,6 +54,56 @@ architecture. It is a reference ledger for Verse discovery, peer exchange, game sessions, simulation fact commitment, and stream catalogs. +## Brokkr + +- `Brokkr:README.md`: Brokkr is the GameCult creative-tool broker daemon. It + lets Unity, Blender, and future editor runtimes expose live authoring + surfaces to the Verse without pretending those runtimes are the same machine. + Brokkr owns the broker contract, provider advertisement, routing policy, and + typed command receipts. Unity and Blender keep editor truth. +- `Brokkr:docs/architecture.md`: the Unity package opens a durable CultMesh node + backed by `.brokkr/unity-editor.ccmp`, writes editor snapshots and command + receipts, and watches typed command-intent documents. The Blender add-on uses + CultLib's Python CultMesh runtime as its local mirror node and can serve that + node for external clients. +- `Brokkr:docs/provider-contract.md`: Brokkr exposes capability families for + mirror publishing, intent watching, host status, scene tree, component state, + selection, asset catalog, object creation, component/property writes, command + receipts, and Eve GUI/TUI publication. It defines Unity and Blender host + snapshots, command intents, receipts, sync sessions, object bindings, sync + vars, and timeline bindings. + +## Weksa, Vili, And Ghostlight + +- `E:\Projects\weksa\README.md`: Weksa is a procedural language engine grounded + in concept, culture, grammar, phonology, morphology, and diachronic history + rather than English word substitution. Its daemon contract owns typed + conversational intent, pronunciation plans, utterance handoffs, and the + Eve/CultMesh surfaces that make those documents inspectable. +- `E:\Projects\weksa\docs\verse-service-contract.md`: Weksa is the + language-intent daemon. It turns writing, dialogue pressure, and agent state + into typed intent, pronunciation, and utterance documents for text, speech, + and synthesis consumers. AquaSynth owns learned speech synthesis and audio; + external speech providers own rendered audio; Weksa owns the accepted + utterance/request projection and trace. +- `Vili:README.md`: Vili is the GameCult Persona animation daemon. It bridges + Persona performance intent to body-motion generation through Kimodo, while + Vili owns job intake, Kimodo runtime checks, resident worker lifecycle, + generated motion artifact references, and provider/operator surfaces. +- `Vili:docs/verse-service-contract.md`: Vili is an animation service, not a + per-request CLI wrapper. It accepts gesture/action prompts, keeps a resident + Kimodo worker warm, publishes job records and motion artifacts, and leaves + retargeting/playback/facial performance/camera/lip sync to future renderers. +- `Ghostlight:notes/fresh-workspace-handoff.md`: Ghostlight's live + product-facing goal is procedural branching scene generation for games: + speech and non-speech actions, NPC responses, consequences, future hooks, and + state/memory/social-perception mutation. +- `Ghostlight:prompts/sandboxed-coordinator-turn.md`: the Ghostlight + coordinator worker moves one scene beat through structured state. It consumes + scene/world state, event records, participant summaries, unresolved hooks, + available characters, clocks, resources, gates, and allowed machinery calls, + then emits the next playable state. + ## Odin And Idunn - `Odin:src/Idunn/README.md`: Idunn is the keepalive daemon for the Odin swarm. diff --git a/docs/gamecult-daemonic-swarm.md b/docs/gamecult-daemonic-swarm.md index 924bdfb..8fd25d1 100644 --- a/docs/gamecult-daemonic-swarm.md +++ b/docs/gamecult-daemonic-swarm.md @@ -126,13 +126,89 @@ The same pattern applies elsewhere: - Mimir owns observation and synchronization interpretation. - VoidBot owns its local swarm state and Persona/tool surfaces. -- Weksa owns utterance intent and lowering. +- Weksa owns language intent, pronunciation, utterance lowering, and delivery + trace. +- Vili owns animation job intake, Kimodo worker lifecycle, and generated motion + artifact references. +- Brokkr owns live creative-tool broker contracts between Unity, Blender, and + the Verse. +- Ghostlight owns scene state coordination, next-beat selection, and playable + consequence records. - StreamPixels owns creator/render pipeline state. - Odin owns discovery and provider aggregation. - Idunn owns daemon continuity and restart witnesses. Each daemon is a small sovereign machine. The swarm is the application. +## The Cinematic Content Swarm + +The strongest current example is not a dashboard. It is the rapid creative +pipeline for cinematic game content. + +The target shape is this: + +```text +Ghostlight scene state + -> Weksa utterance and delivery intent + -> AquaSynth or external speech provider voice output + -> Vili/Kimodo body-motion generation + -> Brokkr Unity/Blender live sync + -> native Eve/editor/game surfaces + -> reviewed scene update +``` + +Each daemon makes the next daemon more capable. + +Ghostlight is the stage coordinator. It owns world and scene state, visible +participants, event history, unresolved hooks, pressures, branch affordances, +and the next playable beat. It decides which actor, lever, or machinery call +should happen next without pretending to be the actor, renderer, or editor. + +Weksa is the language and speech-intent engine. It can be used by any character +or Persona as a mouth, throat, and stage-instruction organ: writing and agent +state enter as intent pressure; Weksa lowers that into target-language +utterances, pronunciation plans, prosody/emphasis hints, speech-provider +requests, and AquaSynth handoff documents. Weksa does not own the audio bytes or +the motion. It owns the inspected delivery intent and trace. + +AquaSynth is one speech and sound body for that intent. It can consume Weksa +handoffs, compile the needed synth/voice machinery, and publish sample or stream +receipts. External speech providers can be other mouths. The important thing is +that Weksa-authored intent remains traceable instead of vanishing into a prompt. + +Vili wraps Kimodo as the animation daemon. Weksa, Personas, or Ghostlight can +propose performance intent, gesture prompts, constraints, and durations. Vili +owns animation job identity, request persistence, Kimodo runtime readiness, the +resident worker lifecycle, and generated motion artifact references. Kimodo owns +motion synthesis. Retargeting, playback, facial performance, camera, and lip +sync belong to their renderer or future provider surfaces. + +Brokkr is the forge broker for live creative tools. Unity and Blender publish +host snapshots, command intents, command receipts, object bindings, sync vars, +and timeline bindings through CultMesh mirrors. Brokkr routes typed editor +observations and admitted commands without stealing editor truth: Unity still +owns Unity scenes, assets, selection, play mode, imports, and editor side +effects; Blender still owns Blender scenes, objects, operators, add-ons, and +render settings. + +That gives us a fast loop: + +1. Ghostlight chooses or updates a scene beat. +2. Weksa gives an actor the line, pronunciation, delivery, and speech handoff. +3. AquaSynth or another speech provider makes the voice. +4. Vili generates body motion from the same performance intent. +5. Brokkr pushes or synchronizes the resulting scene, object, camera, timeline, + and asset changes into Unity and Blender. +6. Eve surfaces let humans inspect, steer, accept, reject, and replay the + receipts. + +The result is not one giant cinematic editor. It is a swarm where language, +voice, motion, scene state, and DCC synchronization remain separate authorities +that can compose. Each daemon is useful alone. Together they become a larger +daemon: a cinematic game-content machine that can move from story pressure to +spoken performance to animated scene state without every app embedding every +capability. + ## The Script Starts The Swarm When a GameCult script says "run the app," it often means "start the local diff --git a/state/evidence.jsonl b/state/evidence.jsonl index 62ebb2c..0e42b62 100644 --- a/state/evidence.jsonl +++ b/state/evidence.jsonl @@ -281,3 +281,4 @@ {"timestamp":"2026-06-15T01:34:00+01:00","topic":"aquasynth-daemon-bounded-automation-stream","claim":"A bounded realtime-shaped automation stream now belongs to AquaSynthDaemonService, not the CLI or a future transport listener. The service compiles once, opens a native Faust streaming patch, applies per-block controls, emits CultMesh-compatible audio/control descriptors and frame handles, writes per-block float32 packet bodies, and persists one stream receipt.","evidence":"src/AquaSynth.Faust/AquaSynthDaemonService.cs; tests/AquaSynth.Dsl.Tests/AquaSynthDaemonServiceTests.cs; tools/AquaSynthDaemon/Program.cs; docs/verse-service-contract.md"} {"timestamp":"2026-06-15T01:42:00+01:00","topic":"aquasynth-local-cultnet-daemon","claim":"AquaSynth now has a local CultNet daemon boundary: typed patch/sample/stream command documents are written to the CultNet database, AquaSynthCultNetDaemon watches and serializes them through AquaSynthDaemonService, and typed compile/render/stream/provider receipts are published back to the database. The service remains the render/session owner; CultNet is transport and publication authority.","evidence":"src/AquaSynth.Faust/AquaSynthCultNetDaemon.cs; tools/AquaSynthDaemon/Program.cs; tests/AquaSynth.Dsl.Tests/AquaSynthDaemonServiceTests.cs; docs/verse-service-contract.md; CLI smokes: cultnet-once returned 2205 sample frames for 0.05s and cultnet-stream returned 2 packet receipts with control frame count 1 on block 1."} {"timestamp":"2026-06-15T02:05:00+01:00","topic":"gamecult-daemonic-swarm-doc","claim":"GameCult app architecture is now documented as a daemonic swarm pattern: the visible window is usually a thin native Eve terminal, while provider daemons own capabilities, typed state, commands, receipts, health, and surfaces. The prior-work ledger ties the article back to AquaSynth, Eve, CultMesh, Odin, Idunn, and public GameCult site references.","evidence":"docs/gamecult-daemonic-swarm.md; docs/daemonic-swarm-prior-work.md; state/map.yaml"} +{"timestamp":"2026-06-15T02:22:00+01:00","topic":"cinematic-daemonic-swarm-pipeline","claim":"The daemonic swarm documentation now includes the creative cinematic pipeline: Ghostlight coordinates scene state and next beats, Weksa lowers writing/agent state into utterance and delivery intent, AquaSynth or external providers produce voice, Vili wraps Kimodo for motion generation, and Brokkr mirrors/synchronizes Unity and Blender through CultMesh without stealing editor truth.","evidence":"docs/gamecult-daemonic-swarm.md; docs/daemonic-swarm-prior-work.md; Brokkr README/docs/provider-contract.md; Vili README/docs/verse-service-contract.md; Ghostlight prompts/sandboxed-coordinator-turn.md; E:/Projects/weksa/docs/verse-service-contract.md"}