2sagaco48 1.0.0

package/src/fiction/seed-control.ts

@@ -0,0 +1,193 @@
+/**
+ * SEED CONTROL — deterministic idea-mix governor + author locks.
+ * ---------------------------------------------------------------------------
+ * Purely local, no model call. Controls the seed-determined concept flow that
+ * feeds the live chapter prompt:
+ *
+ *   1. EMPTY-SPACE vs HUMAN-SEEN MIX — per-chapter ratio (0-100%) of
+ *      system-scale directives (infrastructure, institutions, ecologies,
+ *      supply chains — the "empty spaces" between human scenes) to
+ *      human-scale directives (relationships, craft, interiority, dialogue).
+ *   2. MOTIFS PER CHAPTER — how many recurring seed motifs are active (0-6).
+ *   3. CONCEPTS PER CHAPTER — target count of new named worldbuilding
+ *      concepts to introduce (0-4); complements (never overrides) the
+ *      continuity governor's hard cap.
+ *   4. AUTHOR LOCKS — setting / core-concept / theme / motif strings that are
+ *      BOTH applied to the snapshot blueprint (so the base SAGE compiler emits
+ *      them) AND injected as hard constraints in the additive seed block.
+ *
+ * Determinism: all per-chapter selections use mulberry32(seed ^ chapterIndex)
+ * so a seed + control state always reproduces the same directives. Logged, so
+ * any prompt can be re-derived by hand.
+ */
+import type { StorySnapshot } from "./types";
+
+export interface AuthorLocks {
+  setting: string;      // overrides primary setting name when non-empty
+  coreConcept: string;  // hard constraint: the book's central device/premise
+  theme: string;        // overrides blueprint theme when non-empty
+  motif: string;        // one author motif seed phrase (added to motif pool)
+}
+
+export interface SeedControl {
+  emptyVsHumanMix: number;   // 0-100: % of directives that are empty-space (system-scale)
+  motifsPerChapter: number;  // 0-6
+  conceptsPerChapter: number;// 0-4
+  locks: AuthorLocks;
+  enabled: boolean;          // master switch; when false the seed block is omitted
+}
+
+export const DEFAULT_SEED_CONTROL: SeedControl = {
+  emptyVsHumanMix: 40,
+  motifsPerChapter: 3,
+  conceptsPerChapter: 2,
+  locks: { setting: "", coreConcept: "", theme: "", motif: "" },
+  enabled: true,
+};
+
+const LS_KEY = "saga.fiction.seedControl.v1";
+
+export function loadSeedControl(): SeedControl {
+  try {
+    const raw = localStorage.getItem(LS_KEY);
+    if (!raw) return { ...DEFAULT_SEED_CONTROL, locks: { ...DEFAULT_SEED_CONTROL.locks } };
+    const p = JSON.parse(raw) as Partial<SeedControl>;
+    return {
+      emptyVsHumanMix: clampInt(p.emptyVsHumanMix, 0, 100, 40),
+      motifsPerChapter: clampInt(p.motifsPerChapter, 0, 6, 3),
+      conceptsPerChapter: clampInt(p.conceptsPerChapter, 0, 4, 2),
+      locks: {
+        setting: String(p.locks?.setting ?? ""),
+        coreConcept: String(p.locks?.coreConcept ?? ""),
+        theme: String(p.locks?.theme ?? ""),
+        motif: String(p.locks?.motif ?? ""),
+      },
+      enabled: p.enabled !== false,
+    };
+  } catch {
+    return { ...DEFAULT_SEED_CONTROL, locks: { ...DEFAULT_SEED_CONTROL.locks } };
+  }
+}
+
+export function saveSeedControl(c: SeedControl): void {
+  try {
+    localStorage.setItem(LS_KEY, JSON.stringify(c));
+  } catch { /* fail-open */ }
+}
+
+function clampInt(v: unknown, lo: number, hi: number, fb: number): number {
+  const n = typeof v === "number" ? v : Number(v);
+  if (!Number.isFinite(n)) return fb;
+  return Math.min(hi, Math.max(lo, Math.round(n)));
+}
+
+/** Local mulberry32 — no package dependency, deterministic. */
+export function mulberry32(seed: number): () => number {
+  let a = seed >>> 0;
+  return () => {
+    a |= 0; a = (a + 0x6d2b79f5) | 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+// ── deterministic directive pools (workspace-side, seed-indexed) ────────────
+const EMPTY_SPACE_DIRECTIVES = [
+  "Surface one piece of working infrastructure (transit, water, power, post, archive) as a lived constraint, not scenery.",
+  "Show an institution acting through a minor functionary whose incentives differ from the protagonist's.",
+  "Let an ecological or weather system impose a cost or delay that cannot be argued away.",
+  "Reveal part of a supply chain: where one ordinary object came from and who was paid too little for it.",
+  "Stage one maintenance ritual (repair, inventory, calibration) that exposes who holds real power here.",
+  "Let a built environment remember: one structure carries visible evidence of a past use that contradicts its present one.",
+  "Introduce one regulatory or customary rule that binds everyone, including the powerful — then enforce it once.",
+  "Show distance as cost: one journey consumes time, money, or health that is not refunded.",
+];
+const HUMAN_SEEN_DIRECTIVES = [
+  "Give two characters a private history that surfaces in subtext, not exposition.",
+  "Let one character perform competence in their craft through specific procedural detail.",
+  "Stage one interior decision where the character chooses against their own stated interest — and dramatize why.",
+  "Let dialogue do double duty: the literal topic differs from what is actually being negotiated.",
+  "Show one relationship's power balance shifting through a small, concrete exchange of objects or favors.",
+  "Let one character misread another's intent, with consequences that persist past the scene.",
+  "Ground one emotional beat in a bodily reflex or habit rather than a named feeling.",
+  "Give one minor character a want that collides obliquely with the protagonist's plan.",
+];
+const MOTIF_POOL = [
+  "keys and thresholds", "ledger-ink and handwriting", "salt and preservation",
+  "bells and signal-hours", "mended cloth", "river crossings", "lamplight after curfew",
+  "sealed letters", "iron tallies", "frost on glass", "harbor foghorns", "copper wire",
+];
+
+export interface SeedDirectives {
+  chapterIndex: number;
+  emptySpace: string[];
+  humanSeen: string[];
+  motifs: string[];
+  conceptsTarget: number;
+}
+
+/** Deterministically select this chapter's seed directives. Pure. */
+export function selectSeedDirectives(seed: number, chapterIndex: number, control: SeedControl): SeedDirectives {
+  const rng = mulberry32(((seed >>> 0) ^ Math.imul(chapterIndex + 1, 0x9e3779b9)) >>> 0);
+  const pick = <T,>(pool: T[], n: number): T[] => {
+    const copy = pool.slice();
+    const out: T[] = [];
+    while (copy.length && out.length < n) out.push(copy.splice(Math.floor(rng() * copy.length), 1)[0]);
+    return out;
+  };
+  const totalSlots = 2;
+  const emptyCount = Math.round((totalSlots * control.emptyVsHumanMix) / 100);
+  const humanCount = totalSlots - emptyCount;
+  const motifs = pick(MOTIF_POOL, Math.max(0, Math.min(6, control.motifsPerChapter)));
+  if (control.locks.motif.trim()) motifs.unshift(control.locks.motif.trim().slice(0, 80));
+  return {
+    chapterIndex,
+    emptySpace: pick(EMPTY_SPACE_DIRECTIVES, emptyCount),
+    humanSeen: pick(HUMAN_SEEN_DIRECTIVES, humanCount),
+    motifs: motifs.slice(0, 7),
+    conceptsTarget: Math.max(0, Math.min(4, control.conceptsPerChapter)),
+  };
+}
+
+/** Additive seed block appended to the live chapter prompt (advisory + locks). */
+export function buildSeedDirectiveBlock(d: SeedDirectives, control: SeedControl): string {
+  if (!control.enabled) return "";
+  const lines: string[] = [];
+  lines.push("SEED DIRECTIVES — deterministic selections for this chapter (seed-derived; locks are binding).");
+  const L = control.locks;
+  if (L.setting.trim() || L.coreConcept.trim() || L.theme.trim()) {
+    lines.push("AUTHOR LOCKS (hard constraints — the chapter MUST honor these):");
+    if (L.setting.trim()) lines.push(`  · LOCKED SETTING: ${L.setting.trim().slice(0, 200)}`);
+    if (L.coreConcept.trim()) lines.push(`  · LOCKED CORE CONCEPT: ${L.coreConcept.trim().slice(0, 300)}`);
+    if (L.theme.trim()) lines.push(`  · LOCKED THEME: ${L.theme.trim().slice(0, 200)}`);
+  }
+  if (d.emptySpace.length) {
+    lines.push("Empty-space beats (system-scale; dramatize, do not lecture):");
+    for (const e of d.emptySpace) lines.push(`  · ${e}`);
+  }
+  if (d.humanSeen.length) {
+    lines.push("Human-scale beats (relationship/craft/interiority):");
+    for (const h of d.humanSeen) lines.push(`  · ${h}`);
+  }
+  if (d.motifs.length) lines.push(`Active motifs this chapter (${d.motifs.length}): ${d.motifs.join("; ")}. Weave at most once each; never list them.`);
+  lines.push(`New named worldbuilding concepts this chapter: introduce EXACTLY ${d.conceptsTarget} (0 means use only established concepts).`);
+  return lines.join("\n");
+}
+
+/**
+ * Apply author locks to a FRESH snapshot (mutates only the passed clone-safe
+ * object). Because the base SAGE compiler reads blueprint fields, a setting /
+ * theme lock changes the base prompt itself — the strongest honest wiring.
+ */
+export function applySeedLocks(snapshot: StorySnapshot, control: SeedControl): void {
+  const L = control.locks;
+  try {
+    if (L.setting.trim()) {
+      (snapshot.blueprint as { primarySetting: { name: string } }).primarySetting.name = L.setting.trim().slice(0, 200);
+    }
+    if (L.theme.trim()) {
+      (snapshot.blueprint as { theme: string }).theme = L.theme.trim().slice(0, 200);
+    }
+  } catch { /* fail-open: locks still apply via the seed block */ }
+}

package/src/fiction/story-engine.ts

@@ -0,0 +1,326 @@
+/**
+ * STORY ENGINE CONTROLLER — live multi-turn fiction pipeline runner.
+ * ---------------------------------------------------------------------------
+ * Provides real start / stop, mid-story model switching, crash recovery,
+ * bounded truncation auto-continuations, and continuity governor injection.
+ * Commits each chapter directly to the engine's message store and dispatches
+ * state updates to the main chat window.
+ */
+import { compileCompactChapterPrompt, rollSage, rollProseCadence, scrubLeakedDirective } from '@/lib/sage/engine';
+import { getPersonaDirective } from '@/lib/williams-style';
+import { detectDegenerateRepetition } from '@/lib/sage/repetition';
+import { generateSynthesizedResponse } from "../lib/models";
+import {
+  buildContinuityBlock,
+  buildContinuationPrompt,
+  extractChapterFacts,
+  foldFacts,
+  normalizeChapterTitle,
+  stripHarnessResidue,
+  truncationVerdict,
+  type ContinuityLedger,
+} from "./continuity";
+import type { StorySnapshot, ContinuityToggles } from "./types";
+import { DEFAULT_CONTINUITY_TOGGLES } from "./types";
+import { buildSeedDirectiveBlock, selectSeedDirectives, type SeedControl } from "./seed-control";
+
+/** Strip a leading "## Title" line the model may echo; keeps body prose intact. */
+function stripEchoedHeading(text: string, title: string): string {
+  const t = (title || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return text
+    .replace(new RegExp(`^#{1,6}\\s*(?:\\d+\\.?\\s*)?${t}\\s*\\n+`, "i"), "")
+    .replace(/^#{1,6}\s+.+\n+/, "")
+    .trim();
+}
+
+/** Full post-generation sanitize: SAGA leak scrub → residue strip → heading echo strip. Never blocks output. */
+function sanitizeChapterBody(raw: string, title: string, toggles: ContinuityToggles): { text: string; notes: string[] } {
+  const notes: string[] = [];
+  let text = scrubLeakedDirective(raw || "");
+  if (toggles.enableFM07ResidueStripping) {
+    const { text: cleaned, removed } = stripHarnessResidue(text);
+    text = cleaned;
+    if (removed.length) notes.push(`residue:${removed.join(",")}`);
+  }
+  const before = text;
+  text = stripEchoedHeading(text, title);
+  if (text !== before) notes.push("heading-echo-stripped");
+  // Never return empty — preserve a minimal non-blocking fallback so a bad scrub cannot stall the novel.
+  if (!text.trim()) {
+    text = (raw || "").trim() || "[DRAFT GAP] Chapter generation returned no substantive prose.";
+    notes.push("fallback-raw-or-gap");
+  }
+  return { text, notes };
+}
+
+/** Hard ceiling on a single chapter-request prompt (chars). Prevents API 400s at max scale. */
+export const MAX_CHAPTER_PROMPT_CHARS = 60000;
+
+/**
+ * Realistic per-model output-word ceiling. Mirrors the package generateGemini
+ * maxOutputTokens ladder (gemini-2.5-pro 32k, gemini-3.x/2.5-flash 16k, gemma
+ * 8k) converted at ~0.72 words/token with headroom. A chapter commissioned
+ * above this ceiling can NEVER complete in one call, so truncationVerdict would
+ * loop the 2 continuations every chapter and still land short. We clamp the
+ * per-call target to the ceiling so the truncation guard only fires on genuine
+ * cutoffs, not on impossible commissions.
+ */
+export function modelWordCeiling(model: string): number {
+  const m = (model || "").toLowerCase();
+  if (/gemini-2\.5-pro/.test(m)) return 20000;
+  if (/gemini-3|gemini-2\.5-flash/.test(m)) return 10000;
+  if (/gemma-4/.test(m)) return 5200;
+  if (/gemma-3/.test(m)) return 5200;
+  return 5200;
+}
+
+async function generateWithOneRetry(
+  params: Parameters<typeof generateSynthesizedResponse>[0],
+  onLog?: (msg: string) => void,
+): Promise<string> {
+  try {
+    return await generateSynthesizedResponse(params);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    // One honest retry after a short backoff: a single network blip must not kill an 80-chapter run.
+    onLog?.(`Chapter call failed (${msg.slice(0, 120)}). Retrying once in 2s…`);
+    await new Promise((r) => setTimeout(r, 2000));
+    return generateSynthesizedResponse(params);
+  }
+}
+
+export interface StoryEngineState {
+  status: "idle" | "running" | "paused" | "error" | "complete";
+  currentChapter: number;
+  totalChapters: number;
+  currentTitle: string;
+  wordCount: number;
+  model: string;
+  error?: string;
+  log: string[];
+}
+
+export interface ChapterOutput {
+  index: number;
+  title: string;
+  text: string;
+  words: number;
+  truncated: boolean;
+  continuationsApplied: number;
+}
+
+export function parseChaptersFromText(text: string): { index: number; title: string; text: string }[] {
+  if (!text.trim()) return [];
+  // Prefer splitting on explicit ## chapter headings (our engine's commit format).
+  // This avoids false positives from bare "Chapter N" dialogue/prose and keeps
+  // resume indices honest at novel scale.
+  const parts = text.split(/(?=^##\s+)/m).map((p) => p.trim()).filter(Boolean);
+  if (parts.length >= 2 || (parts.length === 1 && /^##\s+/.test(parts[0]))) {
+    const out: { index: number; title: string; text: string }[] = [];
+    let idx = 1;
+    for (const part of parts) {
+      const lines = part.split("\n");
+      const head = lines[0] ?? "";
+      const m = head.match(/^##\s+(?:(\d+)\.?\s*)?(.*)$/);
+      if (!m) continue;
+      const body = lines.slice(1).join("\n").trim();
+      // Skip empty/preamble-only blocks so a title page doesn't inflate chapter count.
+      if (!body || body.length < 40) continue;
+      const title = (m[2] || `Chapter ${idx}`).trim() || `Chapter ${idx}`;
+      out.push({ index: idx++, title, text: body });
+    }
+    if (out.length > 0) return out;
+  }
+  // Fallback: single-block manuscript without ## headings.
+  return [{ index: 1, title: "Chapter 1", text: text.trim() }];
+}
+
+export async function generateSingleChapterWithContinuity(args: {
+  snapshot: StorySnapshot;
+  chapterIndex: number;
+  model: string;
+  apiKey: string;
+  provider?: string;
+  ledger: ContinuityLedger;
+  toggles?: ContinuityToggles;
+  priorSummary: string | null;
+  signal?: AbortSignal;
+  onLog?: (msg: string) => void;
+  seedControl?: SeedControl | null;
+}): Promise<{ chapterText: string; updatedLedger: ContinuityLedger; facts: any }> {
+  const {
+    snapshot,
+    chapterIndex,
+    model,
+    apiKey,
+    provider = "gemini",
+    ledger,
+    toggles = DEFAULT_CONTINUITY_TOGGLES,
+    priorSummary,
+    signal,
+    onLog,
+    seedControl = null,
+  } = args;
+
+  const bp = snapshot.blueprint;
+  const ch = bp.chapters[chapterIndex];
+  if (!ch) throw new Error(`Chapter ${chapterIndex + 1} is out of bounds (total ${bp.chapters.length})`);
+
+  let title = ch.title;
+  if (toggles.enableFM06TitleNormalization) {
+    title = normalizeChapterTitle(title);
+  }
+
+  const cadence = bp.cadence || rollProseCadence(bp.seed, bp.tone || "mythic", bp.macro?.name || "The Hero's Journey");
+  const basePrompt = compileCompactChapterPrompt(bp, chapterIndex, priorSummary, cadence);
+  const styleBlock = getPersonaDirective("The Architect");
+  const continuityBlock = buildContinuityBlock({
+    snapshot,
+    chapterIndex,
+    ledger,
+    toggles,
+  });
+
+  const seedBlock = seedControl?.enabled
+    ? buildSeedDirectiveBlock(selectSeedDirectives(snapshot.seed, chapterIndex, seedControl), seedControl)
+    : "";
+  if (seedBlock) onLog?.(`Seed directives injected (mix ${seedControl!.emptyVsHumanMix}% empty-space, ${seedControl!.motifsPerChapter} motifs, ${seedControl!.conceptsPerChapter} concepts).`);
+
+  // Order: style → base SAGE prompt → seed directives → continuity ledger.
+  // Continuity keeps the recency slot (it ends with "Write ONLY the chapter prose now.").
+  let fullPrompt = [
+    styleBlock ? `STYLE PERSONA:\n${styleBlock}` : "",
+    basePrompt,
+    "",
+    seedBlock,
+    continuityBlock,
+  ]
+    .filter(Boolean)
+    .join("\n\n");
+
+  // Prompt-size guard: trim the additive continuity block (never the base prompt) if oversized.
+  if (fullPrompt.length > MAX_CHAPTER_PROMPT_CHARS) {
+    const over = fullPrompt.length - MAX_CHAPTER_PROMPT_CHARS;
+    const trimmedContinuity = continuityBlock.slice(0, Math.max(2000, continuityBlock.length - over));
+    fullPrompt = [styleBlock ? `STYLE PERSONA:\n${styleBlock}` : "", basePrompt, "", seedBlock, trimmedContinuity]
+      .filter(Boolean)
+      .join("\n\n");
+    onLog?.(`Prompt capped to ${fullPrompt.length} chars (continuity block trimmed, base prompt intact).`);
+  }
+
+  onLog?.(`Sending chapter ${chapterIndex + 1} prompt to ${model} (${fullPrompt.length} chars)...`);
+
+  const callOnce = async (): Promise<string> => {
+    const raw = await generateWithOneRetry({
+      provider: provider as any,
+      model: model as any,
+      apiKey,
+      userMessage: fullPrompt,
+      retrievedWebData: [],
+      conversationHistory: [],
+    }, onLog);
+    const { text, notes } = sanitizeChapterBody(raw, title, toggles);
+    if (notes.length) onLog?.(`Sanitize: ${notes.join("; ")}`);
+    return text;
+  };
+
+  let cleanText = await callOnce();
+  if (signal?.aborted) throw new Error("Generation aborted by user.");
+
+  // SAGA repetition guard (package detectDegenerateRepetition): one fresh regen, never re-feed poisoned draft.
+  // Advisory only — a still-flagged second attempt is kept so the novel never stalls.
+  try {
+    const rep = detectDegenerateRepetition(cleanText);
+    if (rep.flagged) {
+      onLog?.(`Repetition guard flagged: ${rep.reasons.join("; ")}. Regenerating fresh (not re-feeding draft)…`);
+      if (!signal?.aborted) {
+        const second = await callOnce();
+        const rep2 = detectDegenerateRepetition(second);
+        cleanText = second;
+        if (rep2.flagged) onLog?.(`Repetition still flagged after regen (${rep2.reasons.join("; ")}); keeping second attempt (best of two).`);
+        else onLog?.("Repetition cleared on second attempt.");
+      }
+    }
+  } catch {
+    /* fail-open: guard must never block generation */
+  }
+
+  // Check truncation & bounded continuation (FM-04) — never blocks; at most 2 continuations.
+  // The truncation TARGET is clamped to what the selected model can actually emit
+  // in one call, so we never chase an impossible commission (see modelWordCeiling).
+  const effectiveTarget = Math.min(ch.targetWords || 1000, modelWordCeiling(model));
+  if ((ch.targetWords || 0) > effectiveTarget) {
+    onLog?.(`Chapter target ${ch.targetWords}w exceeds ${model} single-call ceiling; using ${effectiveTarget}w for the truncation check.`);
+  }
+  let continuations = 0;
+  if (toggles.enableFM04TruncationRecovery) {
+    let verdict = truncationVerdict(cleanText, effectiveTarget);
+    while (verdict.truncated && continuations < 2 && !signal?.aborted) {
+      onLog?.(`Chapter truncated (${verdict.reason}). Executing continuation ${continuations + 1}/2...`);
+      const contPrompt = buildContinuationPrompt({
+        snapshot,
+        chapterIndex,
+        title,
+        sofar: cleanText,
+        targetWords: effectiveTarget,
+      });
+
+      const contRaw = await generateWithOneRetry({
+        provider: provider as any,
+        model: model as any,
+        apiKey,
+        userMessage: contPrompt,
+        retrievedWebData: [],
+        conversationHistory: [],
+      }, onLog);
+
+      const contClean = sanitizeChapterBody(contRaw, title, toggles).text;
+      // Append only the novel tail — drop any re-echoed prefix the model may have repeated.
+      cleanText = `${cleanText.trim()}\n\n${contClean.trim()}`;
+      continuations++;
+      verdict = truncationVerdict(cleanText, effectiveTarget);
+    }
+    if (verdict.truncated) onLog?.(`Still short after ${continuations} continuation(s); committing best available (no stall).`);
+  }
+
+  const facts = extractChapterFacts({
+    chapter: chapterIndex + 1,
+    title,
+    text: cleanText,
+    snapshot,
+  });
+
+  const updatedLedger = foldFacts(ledger, facts);
+
+  return {
+    chapterText: cleanText,
+    updatedLedger,
+    facts,
+  };
+}
+
+/** Creates a safe standalone snapshot from current seed and settings. */
+export function createStorySnapshot(seed: number, chaptersCount = 16): StorySnapshot {
+  const bp = rollSage({
+    seed,
+    chapters: chaptersCount,
+  });
+
+  return {
+    blueprint: bp,
+    seed,
+    roll: {
+      world: [
+        { label: bp.primarySetting.name, desc: bp.primarySetting.name },
+        ...bp.secondarySettings.map((s) => ({ label: s.name, desc: s.name })),
+      ],
+      cast: {
+        cast: [
+          { name: bp.protagonist.archetype.name, role: bp.protagonist.role },
+          { name: bp.deuteragonist.archetype.name, role: bp.deuteragonist.role },
+          { name: bp.antagonist.archetype.name, role: bp.antagonist.role },
+        ],
+      },
+    },
+  };
+}

package/src/fiction/types.ts

@@ -0,0 +1,68 @@
+/**
+ * FICTION TYPES — story snapshot, continuity, and generation contracts.
+ */
+import type { SageBlueprint } from '@/lib/sage/engine';
+
+export interface CastMember {
+  name: string;
+  kind?: string;
+  role?: string;
+  archetype?: string;
+  [key: string]: unknown;
+}
+
+export interface WorldPlace {
+  label: string;
+  kind?: string;
+  desc?: string;
+  [key: string]: unknown;
+}
+
+export interface StorySnapshot {
+  blueprint: SageBlueprint;
+  roll: {
+    world: WorldPlace[];
+    cast: { cast: CastMember[] };
+    [key: string]: unknown;
+  };
+  seed: number;
+  cadenceSeed?: number;
+  realityLevel?: number;
+  [key: string]: unknown;
+}
+
+export interface ContinuityToggles {
+  enableFM02ContinueFrom: boolean;
+  enableFM03AntiStasis: boolean;
+  enableFM04TruncationRecovery: boolean;
+  enableFM05MotifCooldown: boolean;
+  enableFM06TitleNormalization: boolean;
+  enableFM07ResidueStripping: boolean;
+  enableFM08PovLock: boolean;
+  enableFM09ActLadder: boolean;
+  enableFM10TransitRules: boolean;
+  enableFM11ConceptBudget: boolean;
+  enableFM12BeatLedger: boolean;
+  enableFM13ClockMonotonicity: boolean;
+  enableFM14MeasurementBudget: boolean;
+  enableFM15CurrencyBudget: boolean;
+  enableFM16IrreversibleLedger: boolean;
+}
+
+export const DEFAULT_CONTINUITY_TOGGLES: ContinuityToggles = {
+  enableFM02ContinueFrom: true,
+  enableFM03AntiStasis: true,
+  enableFM04TruncationRecovery: true,
+  enableFM05MotifCooldown: true,
+  enableFM06TitleNormalization: true,
+  enableFM07ResidueStripping: true,
+  enableFM08PovLock: true,
+  enableFM09ActLadder: true,
+  enableFM10TransitRules: true,
+  enableFM11ConceptBudget: true,
+  enableFM12BeatLedger: true,
+  enableFM13ClockMonotonicity: true,
+  enableFM14MeasurementBudget: true,
+  enableFM15CurrencyBudget: true,
+  enableFM16IrreversibleLedger: true,
+};