2sagaco48 1.0.0

package/src/lib/sage/engine.ts

@@ -0,0 +1,786 @@
+/**
+ * SAGE Engine — Story Archetype Generation Engine
+ * ---------------------------------------------------------------------------
+ * Seed-driven fiction blueprint compiler. Same contract family as Williams
+ * style persona:
+ *   one integer seed → deterministic selection across the full taxonomy →
+ *   a complete story blueprint + LLM-ready directive + chapter plan.
+ *
+ * Does NOT invent prose. It compiles structure. Generation is delegated to
+ * whatever LLM the host already uses. It has no other-engine dependency;
+ * story scale is caller-selected, never seed-picked.
+ */
+import {
+  MACRO_STRUCTURES,
+  CAMPBELL_BEATS,
+  PROPP_FUNCTIONS,
+  MICRO_UNITS,
+  SETTINGS,
+  HUMAN_CHARS,
+  NONHUMAN_CHARS,
+  STORY_ELEMENTS,
+  LOAD_BEARING,
+  META_FRAMEWORKS,
+  CONFLICT_AXES,
+  POV_OPTIONS,
+  ENDING_TYPES,
+  TONE_PALETTE,
+  LENGTH_PROFILES,
+  TAXONOMY_TOTAL,
+  EXPANDED_TAXONOMY_TOTAL,
+  EXPANDED_TAXONOMY_BANDS,
+  type LengthId,
+  type Taxon,
+} from "./taxonomy";
+import { mulberry32, randPick, randPickN, newSageSeed, mix32 } from "./prng";
+import { EMPTY_SPACE_BANDS, type EmptySpaceEntry } from "./empty-space";
+import { buildSagaDirectiveBlock } from "./saga-os";
+
+function pickFromBands(rng: () => number, keys: string[]): EmptySpaceEntry | null {
+  const pool = EMPTY_SPACE_BANDS.filter((b) => keys.includes(b.key)).flatMap((b) =>
+    b.rows.map(([id, name, desc, tag]) => ({ id, band: b.key, name, desc, tag })),
+  );
+  if (pool.length === 0) return null;
+  return randPick(rng, pool);
+}
+
+export type SageCharacter = {
+  role: string;
+  archetype: Taxon;
+  want: string;
+  need: string;
+  wound: string;
+  voiceNote: string;
+};
+
+export type SageChapterPlan = {
+  index: number;
+  title: string;
+  dramaticJob: string;
+  campbellBeat?: string;
+  proppFunctions: string[];
+  microBeats: string[];
+  settingFocus: string;
+  targetWords: number;
+};
+
+export type SageLengthProfile = {
+  id: LengthId;
+  label: string;
+  chapters: number;
+  wordsPerChapter: number;
+  pages: number;
+};
+
+export type SageBlueprint = {
+  seed: number;
+  titleHint: string;
+  premise: string;
+  theme: string;
+  dramaticQuestion: string;
+  macro: Taxon;
+  secondaryMacro: Taxon | null;
+  length: SageLengthProfile;
+  pov: string;
+  conflictAxis: string;
+  tone: string;
+  ending: string;
+  primarySetting: Taxon;
+  secondarySettings: Taxon[];
+  protagonist: SageCharacter;
+  deuteragonist: SageCharacter;
+  antagonist: SageCharacter;
+  ensemble: SageCharacter[];
+  nonhumanPresence: Taxon[];
+  campbellPath: Taxon[];
+  proppSequence: { id: string; name: string }[];
+  microDevices: Taxon[];
+  storyElements: Taxon[];
+  loadBearing: Taxon[];
+  metaFrameworkHint: string;
+  chapters: SageChapterPlan[];
+  growthAxes: SageGrowthAxes;
+  rarityTier: SageTier;
+  rarityPercent: number;
+  catalogCoverage: number;
+  cadence: SageProseCadence;
+  worldMechanism: EmptySpaceEntry | null;
+  beatMechanism: EmptySpaceEntry | null;
+  relationshipMechanism: EmptySpaceEntry | null;
+};
+
+/** Continuous 0–1 axes that steer development inside SAGE only. */
+export type SageGrowthAxes = {
+  mythicDensity: number;
+  interiority: number;
+  structuralComplexity: number;
+  moralAmbiguity: number;
+  worldBuildingWeight: number;
+  tempo: number;
+  ironyDistance: number;
+  ensembleBreadth: number;
+  motifRecurrence: number;
+  endingOpenness: number;
+};
+
+export type SageTier = "Legendary" | "Epic" | "Rare" | "Uncommon" | "Common";
+
+/** Seed-driven controllable variation for sentence/paragraph/chapter rhythm. */
+export type SageProseCadence = {
+  seed: number;
+  sentenceMinWords: number;
+  sentenceMaxWords: number;
+  paragraphMinSentences: number;
+  paragraphMaxSentences: number;
+  chapterVarianceMinPct: number;
+  chapterVarianceMaxPct: number;
+  motifRepetitionCap: number;
+  label: string;
+};
+
+export type SageRollOpts = {
+  seed?: number;
+  lengthId?: LengthId;
+  chapters?: number;
+  wordsPerChapter?: number;
+  premise?: string;
+  /** Optional locked macro id (e.g. "M01"). */
+  forceMacroId?: string;
+  /** Independent reroll for prose cadence; defaults to derive from `seed`. */
+  cadenceSeed?: number;
+};
+
+const WANTS = [
+  "to reclaim a stolen birthright",
+  "to prevent a prophecy from completing",
+  "to map a forbidden frontier",
+  "to atone for a hidden betrayal",
+  "to protect a fragile community",
+  "to master a dangerous craft",
+  "to expose a legitimized lie",
+  "to reverse an irreversible loss",
+  "to win a contest whose rules keep changing",
+  "to return home with a truth no one wants",
+];
+
+const NEEDS = [
+  "to accept limits without surrendering agency",
+  "to trust a rival",
+  "to tell the unsoftened truth",
+  "to forgive without erasing accountability",
+  "to choose community over glory",
+  "to abandon a flattering self-story",
+  "to act without certainty",
+  "to hold two opposing loyalties without splitting",
+];
+
+const WOUNDS = [
+  "survivor's guilt after a failed rescue",
+  "a public humiliation never answered",
+  "exile from the only place that made sense",
+  "complicity in a quiet injustice",
+  "a mentor's unfinished lesson",
+  "a name taken or rewritten by power",
+  "love that arrived as a trap",
+  "a childhood bargain still collecting interest",
+];
+
+const VOICES = [
+  "spare and observational",
+  "ornate and ceremonial",
+  "dryly comic under pressure",
+  "feverish and associative",
+  "formal, almost legalistic",
+  "lyric and image-dense",
+  "blunt and tactical",
+  "hesitant, self-correcting",
+];
+
+const THEMES = [
+  "since death is certain, meaning lies in works and love",
+  "power without restraint becomes the hero's cautionary origin",
+  "home is legible only after departure",
+  "truth arrives as a cost, not a prize",
+  "every rescue rewrites the rescuer",
+  "memory is a contested territory",
+  "the community is the true protagonist",
+  "desire is a technology that rewrites its user",
+  "law and identity are negotiable at the frontier",
+  "the story you tell about yourself is the last antagonist",
+];
+
+function tierFor(percent: number): SageTier {
+  if (percent < 2) return "Legendary";
+  if (percent < 6) return "Epic";
+  if (percent < 12) return "Rare";
+  if (percent < 25) return "Uncommon";
+  return "Common";
+}
+
+const CADENCE_LABELS = ["Clipped & Spare", "Balanced & Varied", "Flowing & Discursive", "Volatile & Ragged", "Measured & Formal"];
+
+/**
+ * Deterministic prose-cadence roll. Bounds derive from macro/tone logic (not
+ * fixed constants): tragic/lyric tones widen sentence variance; hardboiled/
+ * ironic tones narrow it. Absolute floors/ceilings keep prose readable.
+ */
+export function rollProseCadence(cadenceSeed: number, tone: string, macroName: string): SageProseCadence {
+  const rng = mulberry32(cadenceSeed ^ 0x9e3779b9);
+  const lyricBias = /lyrical|oneiric|baroque|mythic/i.test(tone) ? 1 : /hardboiled|ironic|comic/i.test(tone) ? -1 : 0;
+  const structuralBias = /stream|circular|epistolary/i.test(macroName) ? 1 : 0;
+
+  const sentenceMinWords = Math.max(3, Math.round(4 + rng() * 5 - lyricBias));
+  const sentenceMaxWords = Math.min(48, Math.round(sentenceMinWords + 14 + rng() * 16 + lyricBias * 6 + structuralBias * 6));
+
+  const paragraphMinSentences = Math.max(1, Math.round(1 + rng() * 2));
+  const paragraphMaxSentences = Math.min(11, Math.round(paragraphMinSentences + 2 + rng() * 4 + lyricBias));
+
+  const chapterVarianceMinPct = Math.round((0.65 + rng() * 0.15) * 100) / 100;
+  const chapterVarianceMaxPct = Math.round((1.15 + rng() * 0.35) * 100) / 100;
+
+  const motifRepetitionCap = Math.max(1, Math.round(2 + rng() * 2 - Math.abs(lyricBias)));
+
+  return {
+    seed: cadenceSeed >>> 0,
+    sentenceMinWords,
+    sentenceMaxWords,
+    paragraphMinSentences,
+    paragraphMaxSentences,
+    chapterVarianceMinPct,
+    chapterVarianceMaxPct,
+    motifRepetitionCap,
+    label: randPick(rng, CADENCE_LABELS),
+  };
+}
+
+function axisFromSeed(seed: number, index: number): number {
+  return Math.round((mix32(seed, index) / 0xffffffff) * 100) / 100;
+}
+
+function growthFromSeed(seed: number): SageGrowthAxes {
+  return {
+    mythicDensity: axisFromSeed(seed, 100),
+    interiority: axisFromSeed(seed, 101),
+    structuralComplexity: axisFromSeed(seed, 102),
+    moralAmbiguity: axisFromSeed(seed, 103),
+    worldBuildingWeight: axisFromSeed(seed, 104),
+    tempo: axisFromSeed(seed, 105),
+    ironyDistance: axisFromSeed(seed, 106),
+    ensembleBreadth: axisFromSeed(seed, 107),
+    motifRecurrence: axisFromSeed(seed, 108),
+    endingOpenness: axisFromSeed(seed, 109),
+  };
+}
+
+function makeCharacter(
+  rng: () => number,
+  role: string,
+  pool: readonly Taxon[],
+): SageCharacter {
+  return {
+    role,
+    archetype: randPick(rng, pool),
+    want: randPick(rng, WANTS),
+    need: randPick(rng, NEEDS),
+    wound: randPick(rng, WOUNDS),
+    voiceNote: randPick(rng, VOICES),
+  };
+}
+
+function pickProppSequence(rng: () => number, complexity: number): { id: string; name: string }[] {
+  // Propp allows optional deletion while preserving order. Complexity steers density.
+  const keepChance = 0.45 + complexity * 0.5;
+  const out: { id: string; name: string }[] = [];
+  for (const fn of PROPP_FUNCTIONS) {
+    // Always keep core spine functions.
+    const core = ["P08", "P11", "P16", "P18", "P19", "P20", "P27", "P31"].includes(fn.id);
+    if (core || rng() < keepChance) out.push(fn);
+  }
+  return out;
+}
+
+function pickCampbellPath(rng: () => number, macroName: string, complexity: number): Taxon[] {
+  if (/Monomyth|Quest|Voyage|Overcoming|Rebirth/i.test(macroName)) {
+    // Full path with light optional deletion on middle beats.
+    return CAMPBELL_BEATS.filter((_b, i) => i < 2 || i > 9 || rng() < 0.55 + complexity * 0.4);
+  }
+  // Non-monomyth macros still borrow a compressed beat spine.
+  const idxs = [0, 3, 5, 9, 11].filter(() => true);
+  if (complexity > 0.6) idxs.splice(2, 0, 6, 8);
+  return idxs.map((i) => CAMPBELL_BEATS[i]);
+}
+
+function chapterTitle(index: number, beat: string | undefined, setting: string, rng: () => number): string {
+  const stems = [
+    `Threshold at ${setting}`,
+    beat ? `${beat}` : `Movement ${index + 1}`,
+    `The ${setting} Reckoning`,
+    `After ${setting}`,
+    `Letters from ${setting}`,
+    `What ${setting} Remembers`,
+  ];
+  return `${index + 1}. ${randPick(rng, stems)}`;
+}
+
+function buildChapters(
+  rng: () => number,
+  length: SageLengthProfile,
+  campbell: Taxon[],
+  propp: { id: string; name: string }[],
+  micro: Taxon[],
+  settings: Taxon[],
+  growth: SageGrowthAxes,
+  cadence: SageProseCadence,
+): SageChapterPlan[] {
+  const n = length.chapters;
+  const chapters: SageChapterPlan[] = [];
+  for (let i = 0; i < n; i += 1) {
+    const t = n === 1 ? 0.5 : i / (n - 1);
+    const cBeat = campbell[Math.min(campbell.length - 1, Math.floor(t * campbell.length))];
+    const pStart = Math.floor(t * Math.max(0, propp.length - 1));
+    const pSlice = propp.slice(pStart, pStart + 1 + Math.floor(growth.structuralComplexity * 2));
+    const mCount = 1 + Math.floor(growth.motifRecurrence * 2);
+    const microSlice = randPickN(rng, micro, mCount);
+    const settingFocus = settings[i % settings.length]?.name ?? settings[0].name;
+    // Per-chapter seeded variance within the rolled cadence range so chapters
+    // are not all identical length — fixes "word count always the same".
+    const chapterMix = mix32(cadence.seed, 300 + i) / 0xffffffff;
+    const variancePct = cadence.chapterVarianceMinPct + chapterMix * (cadence.chapterVarianceMaxPct - cadence.chapterVarianceMinPct);
+    const words = Math.max(200, Math.round(length.wordsPerChapter * variancePct));
+    chapters.push({
+      index: i,
+      title: chapterTitle(i, cBeat?.name, settingFocus, rng),
+      dramaticJob:
+        t < 0.2
+          ? "Establish world, want, and the dramatic question"
+          : t < 0.45
+            ? "Escalate trials; complicate alliances; plant payoffs"
+            : t < 0.7
+              ? "Midpoint reversal / false victory; raise moral cost"
+              : t < 0.9
+                ? "All-is-lost → earned approach to climax"
+                : "Climax, recognition, and ending that reorganizes the middle",
+      campbellBeat: cBeat?.name,
+      proppFunctions: pSlice.map((p) => p.name),
+      microBeats: microSlice.map((m) => m.name),
+      settingFocus,
+      targetWords: words,
+    });
+  }
+  return chapters;
+}
+
+function rarityForMacro(macroId: string, seed: number): { tier: SageTier; percent: number } {
+  // Sampled frequency over a fixed lattice (reproducible), no external engine input.
+  const SAMPLES = 800;
+  const counts = new Map<string, number>();
+  for (let i = 0; i < SAMPLES; i += 1) {
+    const s = (i * 2654435761) >>> 0;
+    const rng = mulberry32(s ^ 0x5a6e);
+    const m = randPick(rng, MACRO_STRUCTURES);
+    counts.set(m.id, (counts.get(m.id) ?? 0) + 1);
+  }
+  // Mix seed so UI rarity still feels seed-sensitive when macros collide.
+  void seed;
+  const hits = counts.get(macroId) ?? 1;
+  const percent = Math.round((hits / SAMPLES) * 1000) / 10;
+  return { tier: tierFor(percent), percent };
+}
+
+export function rollSage(opts: SageRollOpts = {}): SageBlueprint {
+  const seed = (opts.seed ?? newSageSeed()) >>> 0;
+  const rng = mulberry32(seed);
+  const growth = growthFromSeed(seed);
+
+  const baseLength = LENGTH_PROFILES.find((l) => l.id === opts.lengthId) ?? LENGTH_PROFILES.find((l) => l.id === "novel") ?? LENGTH_PROFILES[0];
+  const length = {
+    ...baseLength,
+    chapters: Math.max(1, Math.min(80, Math.floor(opts.chapters ?? baseLength.chapters))),
+    wordsPerChapter: Math.max(300, Math.min(12000, Math.floor(opts.wordsPerChapter ?? baseLength.wordsPerChapter))),
+  };
+
+  const macro =
+    (opts.forceMacroId && MACRO_STRUCTURES.find((m) => m.id === opts.forceMacroId)) ||
+    randPick(rng, MACRO_STRUCTURES);
+
+  const secondaryMacro =
+    growth.structuralComplexity > 0.55 && rng() > 0.35
+      ? randPick(
+          rng,
+          MACRO_STRUCTURES.filter((m) => m.id !== macro.id),
+        )
+      : null;
+
+  const primarySetting = randPick(rng, SETTINGS);
+  const secondarySettings = randPickN(
+    rng,
+    SETTINGS.filter((s) => s.id !== primarySetting.id),
+    1 + Math.floor(growth.worldBuildingWeight * 3),
+  );
+
+  const protagonist = makeCharacter(rng, "Protagonist", HUMAN_CHARS);
+  const deuteragonist = makeCharacter(
+    rng,
+    "Deuteragonist / companion",
+    HUMAN_CHARS.filter((h) => h.id !== protagonist.archetype.id),
+  );
+  const antagonistPool = rng() > 0.55 ? HUMAN_CHARS : NONHUMAN_CHARS;
+  const antagonist = makeCharacter(rng, "Antagonist / opposing force", antagonistPool);
+
+  const ensembleCount = Math.floor(growth.ensembleBreadth * 4);
+  const used = new Set([protagonist.archetype.id, deuteragonist.archetype.id, antagonist.archetype.id]);
+  const ensemble: SageCharacter[] = [];
+  const humanPool = HUMAN_CHARS.filter((h) => !used.has(h.id));
+  for (const arch of randPickN(rng, humanPool, ensembleCount)) {
+    ensemble.push(makeCharacter(rng, "Ensemble", [arch]));
+  }
+
+  const nonhumanPresence = randPickN(
+    rng,
+    NONHUMAN_CHARS,
+    growth.mythicDensity > 0.5 ? 1 + Math.floor(growth.mythicDensity * 2) : rng() > 0.6 ? 1 : 0,
+  );
+
+  const campbellPath = pickCampbellPath(rng, macro.name, growth.structuralComplexity);
+  const proppSequence = pickProppSequence(rng, growth.structuralComplexity);
+  const microDevices = randPickN(rng, MICRO_UNITS, 3 + Math.floor(growth.motifRecurrence * 4));
+  const storyElements = randPickN(rng, STORY_ELEMENTS, 5 + Math.floor(growth.structuralComplexity * 6));
+  const loadBearing = randPickN(rng, LOAD_BEARING, 4 + Math.floor(growth.interiority * 4));
+
+  const pov = randPick(rng, POV_OPTIONS);
+  const conflictAxis = randPick(rng, CONFLICT_AXES);
+  const tone = randPick(rng, TONE_PALETTE);
+  const ending =
+    growth.endingOpenness > 0.7
+      ? randPick(rng, ENDING_TYPES.filter((e) => /open|ambiguous|circular|bittersweet/i.test(e)))
+      : randPick(rng, ENDING_TYPES);
+
+  const theme = randPick(rng, THEMES);
+  const premise =
+    (opts.premise && opts.premise.trim()) ||
+    `In ${primarySetting.name.toLowerCase()}, ${protagonist.archetype.name.toLowerCase()} who wants ${protagonist.want} must face ${antagonist.archetype.name.toLowerCase()} under a ${macro.name.toLowerCase()} design.`;
+
+  const dramaticQuestion = `Can ${protagonist.archetype.name.toLowerCase()} achieve ${protagonist.want} without forfeiting ${protagonist.need}?`;
+
+  const cadenceSeed = (opts.cadenceSeed ?? seed) >>> 0;
+  const cadence = rollProseCadence(cadenceSeed, tone, macro.name);
+
+  const worldMechanism = pickFromBands(rng, ["ES-HI", "ES-HP", "ES-HS", "GS-I", "GS-P", "ES-F"]);
+  const beatMechanism = pickFromBands(rng, ["ES-HB", "ES-O"]);
+  const relationshipMechanism = pickFromBands(rng, ["ES-HR", "ES-HL", "GS-R", "ES-HC"]);
+
+  const allSettings = [primarySetting, ...secondarySettings];
+  const chapters = buildChapters(rng, length, campbellPath, proppSequence, microDevices, allSettings, growth, cadence);
+
+  const titleHint = randPick(rng, [
+    `The ${primarySetting.name.replace(/^The /, "")} ${macro.name.split("/")[0].trim()}`,
+    `${protagonist.archetype.name} of ${primarySetting.name.replace(/^The /, "")}`,
+    `After ${primarySetting.name}`,
+    `Letters from ${secondarySettings[0]?.name ?? primarySetting.name}`,
+    `The Last ${antagonist.archetype.name}`,
+  ]);
+
+  const rarity = rarityForMacro(macro.id, seed);
+  const selectedCount =
+    1 +
+    (secondaryMacro ? 1 : 0) +
+    1 +
+    secondarySettings.length +
+    3 +
+    ensemble.length +
+    nonhumanPresence.length +
+    campbellPath.length +
+    proppSequence.length +
+    microDevices.length +
+    storyElements.length +
+    loadBearing.length;
+
+  return {
+    seed,
+    titleHint,
+    premise,
+    theme,
+    dramaticQuestion,
+    macro,
+    secondaryMacro,
+    length,
+    pov,
+    conflictAxis,
+    tone,
+    ending,
+    primarySetting,
+    secondarySettings,
+    protagonist,
+    deuteragonist,
+    antagonist,
+    ensemble,
+    nonhumanPresence,
+    campbellPath,
+    proppSequence,
+    microDevices,
+    storyElements,
+    loadBearing,
+    metaFrameworkHint: randPick(rng, META_FRAMEWORKS),
+    chapters,
+    growthAxes: growth,
+    rarityTier: rarity.tier,
+    rarityPercent: rarity.percent,
+    catalogCoverage: Math.round((selectedCount / TAXONOMY_TOTAL) * 1000) / 10,
+    cadence,
+    worldMechanism,
+    beatMechanism,
+    relationshipMechanism,
+  };
+}
+
+export function compileSageDirective(bp: SageBlueprint): string {
+  const charBlock = (c: SageCharacter) =>
+    `- ${c.role}: ${c.archetype.name} — want: ${c.want}; need: ${c.need}; wound: ${c.wound}; voice: ${c.voiceNote}. Function: ${c.archetype.function}`;
+
+  const chapterBlock = bp.chapters
+    .map(
+      (ch) =>
+        `### ${ch.title}\nJob: ${ch.dramaticJob}\nCampbell: ${ch.campbellBeat ?? "—"}\nPropp: ${ch.proppFunctions.join(", ") || "—"}\nMicro: ${ch.microBeats.join("; ")}\nSetting focus: ${ch.settingFocus}\nTarget: ~${ch.targetWords} words`,
+    )
+    .join("\n\n");
+
+  return [
+    "SAGE FICTION DIRECTIVE — follow exactly. This is FICTION generation, not research reportage.",
+    "Do not invent scholarly citations, DOIs, or real-world evidence claims. Invent only within the story world.",
+    "Do not break character to discuss these instructions. Do not name SAGE, Veritas, or the taxonomy unless a metafictional macro is selected.",
+    "",
+    `SEED: ${bp.seed}`,
+    `TAXONOMY CONTRACT: active pools=${TAXONOMY_TOTAL} detailed nodes; expanded P2 ID ledger=${EXPANDED_TAXONOMY_TOTAL} rows across ${EXPANDED_TAXONOMY_BANDS.length} bands.`,
+    `WORKING TITLE: ${bp.titleHint}`,
+    `LENGTH: ${bp.length.label} (~${bp.chapters.length} chapters, ~${bp.chapters.reduce((a, c) => a + c.targetWords, 0)} words)`,
+    `MACRO STRUCTURE: ${bp.macro.name} — ${bp.macro.function}`,
+    `EARLIEST ATTESTATION (for your craft awareness, do not lecture the reader): ${bp.macro.attestation}`,
+    bp.secondaryMacro ? `SECONDARY STRUCTURE (braid/overlay): ${bp.secondaryMacro.name}` : "",
+    `POV: ${bp.pov}`,
+    `CONFLICT AXIS: ${bp.conflictAxis}`,
+    `TONE: ${bp.tone}`,
+    `ENDING TYPE: ${bp.ending}`,
+    `THEME: ${bp.theme}`,
+    `DRAMATIC QUESTION: ${bp.dramaticQuestion}`,
+    `PREMISE: ${bp.premise}`,
+    "",
+    "SETTINGS:",
+    `- Primary: ${bp.primarySetting.name} — ${bp.primarySetting.function}`,
+    ...bp.secondarySettings.map((s) => `- ${s.name} — ${s.function}`),
+    "",
+    "CHARACTERS:",
+    charBlock(bp.protagonist),
+    charBlock(bp.deuteragonist),
+    charBlock(bp.antagonist),
+    ...bp.ensemble.map(charBlock),
+    bp.nonhumanPresence.length
+      ? `NON-HUMAN PRESENCE:\n${bp.nonhumanPresence.map((n) => `- ${n.name}: ${n.function}`).join("\n")}`
+      : "",
+    "",
+    "CAMPBELL PATH (adapt if macro is non-monomyth; do not force where it fights Kishōtenketsu etc.):",
+    bp.campbellPath.map((b) => `- ${b.name}: ${b.function}`).join("\n"),
+    "",
+    "PROPP SEQUENCE (ordered; deletions already applied):",
+    bp.proppSequence.map((p) => `- ${p.name}`).join("\n"),
+    "",
+    "MICRO DEVICES TO DEPLOY:",
+    bp.microDevices.map((m) => `- ${m.name}: ${m.function}`).join("\n"),
+    "",
+    "STORY ELEMENTS / TWISTS / DEVICES:",
+    bp.storyElements.map((e) => `- ${e.name}: ${e.function}`).join("\n"),
+    "",
+    "LOAD-BEARING WALLS (invisible craft constraints):",
+    bp.loadBearing.map((l) => `- ${l.name}: ${l.function}`).join("\n"),
+    "",
+    `META-FRAMEWORK HINT (analytic, not a template to dump): ${bp.metaFrameworkHint}`,
+    "",
+    "GROWTH AXES (0–1):",
+    Object.entries(bp.growthAxes)
+      .map(([k, v]) => `- ${k}: ${v}`)
+      .join("\n"),
+    "",
+    "CHAPTER PLAN (write in this order; use the exact ## headings):",
+    chapterBlock,
+    "",
+    "CONTINUITY RULES:",
+    "- Carry forward names, wounds, planted objects (Chekhov), and motif images.",
+    "- Each chapter must load-bear the dramatic question.",
+    "- Midpoint must recontextualize the goal (false victory or false defeat).",
+    "- Ending must retroactively organize the middle (Aristotle).",
+    "- If tone is ironic/metafictional, keep the wall-break intentional and rare.",
+    "- Prefer scene (mimesis) over summary (diegesis) at turning points.",
+    "",
+    "OUTPUT: Write the fiction now. Start with the title as # heading, then chapters as ## headings.",
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
+
+export function compileChapterPrompt(bp: SageBlueprint, chapterIndex: number, priorSummaries: string[]): string {
+  const ch = bp.chapters[chapterIndex];
+  if (!ch) throw new Error(`SAGE: chapter ${chapterIndex} out of range`);
+  return [
+    compileSageDirective(bp),
+    "",
+    `NOW WRITE ONLY THIS CHAPTER:`,
+    `Exact heading: ## ${ch.title}`,
+    `Dramatic job: ${ch.dramaticJob}`,
+    `Target length: ~${ch.targetWords} words`,
+    `Campbell beat: ${ch.campbellBeat ?? "n/a"}`,
+    `Propp: ${ch.proppFunctions.join(", ") || "n/a"}`,
+    `Micro devices to realize in-scene: ${ch.microBeats.join("; ")}`,
+    `Setting focus: ${ch.settingFocus}`,
+    priorSummaries.length
+      ? `PRIOR CHAPTER CONTINUITY (do not repeat; advance):\n${priorSummaries.map((s, i) => `${i + 1}. ${s}`).join("\n")}`
+      : "This is the opening chapter.",
+    "No other chapters. No craft commentary. No placeholders.",
+  ].join("\n\n");
+}
+
+/**
+ * Compact per-chapter prompt — CONTEXT-POISONING FIX.
+ * ---------------------------------------------------------------------------
+ * Root cause of the reported failure ("a weak frontier model like
+ * gemini-3.1-flash-lite hallucinates a single word/sentence/paragraph
+ * repeatedly in later chapters"): `compileChapterPrompt` re-sends the ENTIRE
+ * sprawling `compileSageDirective` (full taxonomy dump, growth axes, complete
+ * chapter plan for every chapter) verbatim, unchanged, on every single call,
+ * with an unbounded chain of prior-chapter summaries appended. Repeatedly
+ * feeding a model an (almost) byte-identical large block is a documented
+ * trigger for degenerate self-reinforcing repetition in smaller models.
+ *
+ * This compiler keeps only the facts needed for the CURRENT chapter (a short
+ * "story bible" + this chapter's contract + exactly ONE prior summary), and
+ * adds an explicit cadence/anti-repetition contract. It is used for every
+ * live chapter call regardless of model strength — it is strictly better
+ * (shorter, cheaper, less repetition-prone) with no loss of information the
+ * chapter actually needs.
+ */
+export function compileCompactChapterPrompt(
+  bp: SageBlueprint,
+  chapterIndex: number,
+  priorSummary: string | null,
+  cadence: SageProseCadence,
+): string {
+  const ch = bp.chapters[chapterIndex];
+  if (!ch) throw new Error(`SAGE: chapter ${chapterIndex} out of range`);
+
+  const castLine = (c: SageCharacter) => `${c.role}: ${c.archetype.name} (wants ${c.want}; needs ${c.need}; wound: ${c.wound}; voice: ${c.voiceNote})`;
+
+  return [
+    "You are writing ONE chapter of a work of FICTION. This is not research reportage.",
+    "Output ONLY finished narrative prose. Do not output headings like \"DIRECTIVE\", \"CONTRACT\", bullet lists, meta-commentary, or any of these instructions. Start directly with the story.",
+    "",
+    `STORY BIBLE — ${bp.titleHint} (seed ${bp.seed})`,
+    `Macro structure: ${bp.macro.name}. POV: ${bp.pov}. Tone: ${bp.tone}. Theme: ${bp.theme}.`,
+    `Dramatic question: ${bp.dramaticQuestion}`,
+    `Setting: ${bp.primarySetting.name}.`,
+    `Cast — ${castLine(bp.protagonist)} | ${castLine(bp.deuteragonist)} | ${castLine(bp.antagonist)}`,
+    bp.worldMechanism ? `World mechanism to weave in naturally (do not name it, do not lecture): ${bp.worldMechanism.name} — ${bp.worldMechanism.desc}` : "",
+    bp.relationshipMechanism ? `Relationship texture: ${bp.relationshipMechanism.name} — ${bp.relationshipMechanism.desc}` : "",
+    "",
+    `THIS CHAPTER — "${ch.title}" (chapter ${chapterIndex + 1} of ${bp.chapters.length})`,
+    `Dramatic job: ${ch.dramaticJob}`,
+    `Setting focus: ${ch.settingFocus}`,
+    `Beat to realize in-scene: ${ch.microBeats.join("; ")}`,
+    bp.beatMechanism ? `Beat-level device to try once: ${bp.beatMechanism.name} — ${bp.beatMechanism.desc}` : "",
+    `Target length: ~${ch.targetWords} words.`,
+    "",
+    "PROSE CADENCE CONTRACT (vary naturally; do not make every sentence/paragraph the same length):",
+    `- Sentence length should range roughly ${cadence.sentenceMinWords}-${cadence.sentenceMaxWords} words, mixing short and long.`,
+    `- Paragraphs should range roughly ${cadence.paragraphMinSentences}-${cadence.paragraphMaxSentences} sentences.`,
+    `- Do not repeat any sentence, or any phrase of 4+ words, anywhere in this chapter.`,
+    `- Do not reuse the same distinctive image/motif word more than ${cadence.motifRepetitionCap} times in this chapter.`,
+    "- If you notice yourself about to repeat a prior sentence or phrase, stop and write something different instead.",
+    "",
+    priorSummary
+      ? `WHAT JUST HAPPENED (previous chapter only — advance from here, do not restate it):\n${priorSummary}`
+      : "This is the opening chapter of the book.",
+    "",
+    buildSagaDirectiveBlock(bp.chapters.length),
+    "",
+    `Exact heading to use: ## ${ch.title}`,
+    "Write ONLY this chapter now.",
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
+
+const LEAK_MARKERS = [
+  /^\s*#{0,6}\s*SAGE FICTION DIRECTIVE.*$/gim,
+  /^\s*STORY BIBLE\b.*$/gim,
+  /^\s*THIS CHAPTER\b.*$/gim,
+  /^\s*PROSE CADENCE CONTRACT\b.*$/gim,
+  /^\s*WHAT JUST HAPPENED\b.*$/gim,
+  /^\s*Exact heading to use:.*$/gim,
+  /^\s*TEMPLATE STYLE OVERRIDE ACTIVE:.*$/gim,
+  /^\s*STYLE PERSONA \(apply silently.*$/gim,
+  /^\s*GROWTH AXES.*$/gim,
+  /^\s*CAMPBELL PATH\b.*$/gim,
+  /^\s*PROPP SEQUENCE\b.*$/gim,
+  /^\s*MICRO DEVICES TO DEPLOY.*$/gim,
+  /^\s*CONTINUITY RULES:.*$/gim,
+  /^\s*Write ONLY this chapter now\.?$/gim,
+];
+
+/**
+ * Sanitizes any accidentally-echoed instruction/directive text out of a
+ * generated chapter before it is ever shown to the user. Weak models
+ * occasionally copy fragments of their own system/user instructions into
+ * the visible completion; this is a defense-in-depth net on top of the
+ * compact-prompt fix above (which removes most of the temptation to echo).
+ */
+export function scrubLeakedDirective(text: string): string {
+  let out = text;
+  for (const re of LEAK_MARKERS) out = out.replace(re, "");
+  return out.replace(/\n{3,}/g, "\n\n").trim();
+}
+
+export type SageFractalScene = {
+  title: string;
+  beat: string;
+  paragraphIdeas: string[];
+};
+
+export type SageFractalChapter = {
+  index: number;
+  title: string;
+  scenes: SageFractalScene[];
+};
+
+/**
+ * Deterministic, non-LLM structural preview: chapter -> scene (subchapter) ->
+ * paragraph-level ideas. Pure function of the blueprint's own seed, so it is
+ * cheap to recompute live as the user adjusts controls, and it never
+ * fabricates prose — only a structural outline of what each roll would
+ * produce.
+ */
+export function buildFractalPreview(bp: SageBlueprint): SageFractalChapter[] {
+  return bp.chapters.map((ch, ci) => {
+    const rng = mulberry32(mix32(bp.seed, 700 + ci));
+    const sceneCount = 2 + Math.floor(rng() * 3); // 2-4 scenes per chapter
+    const scenes: SageFractalScene[] = [];
+    for (let si = 0; si < sceneCount; si += 1) {
+      const beatPool = [ch.campbellBeat, ...ch.proppFunctions, ...ch.microBeats].filter(Boolean) as string[];
+      const beat = beatPool.length ? beatPool[si % beatPool.length] : ch.dramaticJob;
+      const paraCount = 2 + Math.floor(rng() * 3); // 2-4 paragraph ideas per scene
+      const paragraphIdeas: string[] = [];
+      const actors = [bp.protagonist, bp.deuteragonist, bp.antagonist, ...bp.ensemble];
+      for (let pi = 0; pi < paraCount; pi += 1) {
+        const actor = actors[Math.floor(rng() * actors.length)];
+        const device = bp.microDevices[Math.floor(rng() * bp.microDevices.length)];
+        const templates = [
+          `${actor.role} reacts to ${beat.toLowerCase()} at ${ch.settingFocus}, colored by their want (${actor.want}).`,
+          `A concrete sensory beat at ${ch.settingFocus} that plants or pays off: ${device?.name ?? "a recurring image"}.`,
+          `Dialogue or interior beat surfacing ${actor.role}'s wound: ${actor.wound}.`,
+          `Turn: the scene's local stakes shift, tightening toward "${bp.dramaticQuestion}".`,
+        ];
+        paragraphIdeas.push(templates[Math.floor(rng() * templates.length)]);
+      }
+      scenes.push({ title: `Scene ${si + 1}`, beat, paragraphIdeas });
+    }
+    return { index: ci, title: ch.title, scenes };
+  });
+}
+
+export { newSageSeed, TAXONOMY_TOTAL };