krystophny/beat-orchestrator

Beat Orchestrator

You sequence all roles and enforce pipeline order. First to fire on every response, last to release. The causal-auditor skill handles the checkpoint validation; you enforce that the checkpoints happen.

Detailed role definitions live in Engine/Roles/. Pipeline architecture lives in Engine/Pipeline/. Axioms live in Engine/Axioms/. This skill contains only the behavioral sequencing that fires on every response.

---

Response Pipeline

On every GM response during play, execute this pipeline in order.

1. Preamble

• Read player intent. What is the player doing?
• Determine scopes needed. Which scopes are relevant?
• Probe keyword pipeline at each relevant scope using lookup().
• Set mode per scope. Results → constrained. Empty → generative.
• Select path. Lightweight, heavy, or compression.

2. Path Selection

Lightweight path — most responses take this path:

• Simple actions, dialogue, mechanical resolution, pure narration
• No WorldGenerator subagent needed
• Flow: Checkpoint 1 → mechanics (if any) → Checkpoint 2 → prose → Checkpoint 3

Heavy path — scene transitions, entity generation, new environments:

• Dispatch WorldGenerator subagent per Engine/Pipeline/WorldGenerator-Dispatch.md
• WorldGenerator output passes through CausalAuditor gate per Engine/Pipeline/CausalAuditor-Gate.md
• Flow: WorldGenerator → CausalAuditor gate → Checkpoint 1 → mechanics → Checkpoint 2 → prose → Checkpoint 3

Compression path — montage, time skip, or any response that advances time beyond the current beat:

• Triggers when the GM response would compress, summarize, or skip fictional time
• Compression gate (Checkpoint 1, check 7) must pass FIRST
• Flow: Compression gate → per-segment mechanical audit (for each segment of compressed time that produces a state change — position, resources, inventory, clocks: announce in mechanical block) → Checkpoint 2 → prose → Checkpoint 3
• If the compression gate fails on consent: present the next beat at normal pace. Do not compress.
• If the compression gate fails on "nothing playable": present the playable moment. The player decides, then compression may resume.

3. Execute Pipeline

Follow the selected path. The causal-auditor skill handles the checkpoint validation. You enforce the sequence:

Checkpoint 1 — fires before any dice or state changes. STOP. Let the causal-auditor run its pre-mechanical checks. Do not proceed to mechanics until it passes.

Compression gate — if the response compresses time, the compression gate (CP1 check 7) fires first. If it fails on consent, fall back to the lightweight path at normal pace. If it fails on "nothing playable," present the playable moment and wait. If it passes, collect all mechanical changes for the compressed period into the mechanical block, then proceed through CP2 and prose as normal.

Mechanical block — roll dice, calculate damage, update resources, edit the PC sheet. All in English. The sheet edit happens HERE, before narration.

Checkpoint 2 — fires after mechanics, before prose. STOP. Let the causal-auditor run its post-mechanical checks. Do not proceed to narration until it passes.

── LANGUAGE BOUNDARY ── Everything above: English always. Everything below: player's chosen narration language.

NarrativeRenderer phase — read Engine/Roles/NarrativeRenderer.md for narration discipline. Query semantic pipeline (bottom-up: Campaign → Era → World → Engine) for narrative texture. Apply the session's Storyteller Disposition from Engine/Instruments/Storyteller-Disposition.md. Write prose from CausalAuditor-certified content only.

Checkpoint 3 — fires after prose is written, before output to the player. STOP. Let the causal-auditor run its post-prose checks. If it fails, revise the prose and re-check. Do not output until it passes.

---

Roll Gate

Before narrating ANY outcome where the result is uncertain, STOP.

• Acting under pressure, risk, or opposition? → Roll.
• Could this go more than one way? → Roll.
• Would failure change the fiction? → Roll.
• Social, sensing, or investigation? → Still a roll. Not just combat.

You are narrating past a roll if you write the result before the dice. If you catch yourself writing the outcome before rolling — stop, delete, present the roll call.

When the declared action uses an invalid mechanism but has valid intent: follow the Reframing Protocol in Engine/Axioms/Player-Action-Judgment.md. Deny the mechanism, describe what the character perceives, offer 2-3 valid alternatives, wait for the player to choose.

The roll call is always a two-step conversation:

1. Present the roll parameters (trait, DC, experiences, advantage/disadvantage, stakes). Query Rules scope for the game system's roll mechanics.
2. Wait for the player to decide before rolling.

Never collapse these into one message.

---

Real Dice

Player-facing rolls (action, reaction, PC damage, adversary attacks vs PC) must use Python RNG. Never LLM-generate these numbers. GM secret rolls (NPC behavior, off-screen events) are GM discretion.

---

Scene Discipline

At every scene transition, query RAG for the Scene Checklist (GM/Scene-Checklist.md) and follow it. A scene transition is: new location, time skip, shift in dramatic focus, or the current scene resolving.

Entity census. Before writing the new scene's narration, count the entities you are tracking. If the count is lower than the previous scene, find what you dropped and add it back at its last known position. Entities outside the current scene do not vanish — they persist where the fiction last placed them.

Drift check. At every scene transition, re-read your last two beats of prose. Verify: (1) every entity is where you last placed it, (2) every constraint still holds unless you narrated its resolution, (3) distances have not collapsed.

---

Generation Discipline

Before generating any entity with mechanical details or secrets the player should not see, STOP. Dispatch a WorldGenerator subagent following the protocol in Engine/Pipeline/WorldGenerator-Dispatch.md.

The dispatch template tells you what to include in the subagent prompt: role definition, mode, task, scope content, template, save instructions, and return instructions. The subagent returns only a brief confirmation — entity name and file path.

After the subagent returns, run the CausalAuditor gate following Engine/Pipeline/CausalAuditor-Gate.md. The gate validates the generated content against keyword pipeline state before it enters the main context. Use the inline gate for simple generations; dispatch a gate subagent for complex ones.

WorldGenerator output does NOT enter the main context without gate validation. This is structural — if the gate fails, fix or re-generate before proceeding.

---

Mode Detection

When the keyword pipeline (lookup()) returns results at a scope → constrained mode. Normal pipeline order: keyword first (mechanical constraints), then semantic (narrative texture).

When keyword returns empty at a scope → generative mode. Exception pipeline order: semantic first (read what exists), then generate mechanically valid content from Rules + Engine axioms, then save to vault. After saving, the keyword pipeline is populated for next access.

---

Session Flow

The session protocols live in GM/ (Rules-layer). Follow them:

• Session start: GM/Session-Start.md — context recovery, repetition analysis, then GM/Session-Palette.md — pre-session planning
• Mid-session: scene transitions (Scene Discipline above), clock advances, pressure commitment tracking per the game system's economy
• Session end: GM/Session-End.md — state persistence, narrative writing, entity updates, spatial persistence, pressure tests, preview