2sagaco48 1.0.0

package/src/lib/sage/saga-os-v3-core.ts

@@ -0,0 +1,1491 @@
+/**
+ * SAGA-OS v3 CORE — SYSTEM v14 (fable.canon)
+ * ---------------------------------------------------------------------------
+ * Type C net-new. Real, deterministic, offline implementations of the v3
+ * subsystems that the package (`saga-os-v2.ts`) carries only as tables and
+ * that its own `SAGA_OS_V3_UNEXECUTED` ledger declares "design only":
+ *
+ *   §6  CATALOG-COMPILER      per-row CompiledElement manifest, FAIL-CLOSED,
+ *                             WIRE-COVERAGE gate, §6.4 deterministic selection
+ *   §7  GENRE HELM v3         human-readable BuildRequest → GenreContract,
+ *                             genre blending (Σ mix = 1), forbidden failures
+ *   §10 ONOMASTRATA v3        NameCultureProfile phonotactics, WFST-style
+ *                             syllable generation, sound-change layers, CLDR
+ *                             field ordering, UTS#39-style confusable skeleton,
+ *                             full §10.4 six-rule cast-confusion audit,
+ *                             NameRegistry reservation, hybrid-contact rule
+ *   §11 MORPHOGENESIS-LATTICE v2  SHA-256 SeedGenome, counter-based PRNG,
+ *                             five typed lattices, NarrativeCell, K0-ranked
+ *                             legal births, audit masks, attractor targets,
+ *                             content-addressed checkpoints, any-length modes
+ *
+ * RUNTIME HONESTY
+ *  - Pure functions. No LLM, no network, no filesystem, no clock inside math.
+ *  - SHA-256 is a real implementation (FIPS 180-4), verified against Node's
+ *    `crypto` in the workspace harness — not the package's `simpleHash`.
+ *  - The catalog is 947 rows (Empty-Space v5–v7 as shipped in the package),
+ *    not "3,000+". The compiler is total over what exists; the number is stated.
+ *  - Naming profiles are INVENTED phonologies with declared rules. They are
+ *    not real-world cultures and are never presented as such (v3 §10.5).
+ */
+
+import {
+  wireCatalog, buildRows, detectPattern, stateHash, fnv1a,
+  SLOT_CLASS_IDS, SLOT_PRECONDITIONS, SLOT_EFFECTS, PATTERN_ENDING,
+  type SlotClassId, type CostAxis, type StakesAxis,
+  type GenreSpec, type EntityRow, type EntityKind, type CellState, type GridTick,
+  type GenesisPattern,
+} from "./saga-os-v2-engines";
+import { GENRE_HELM, KALLOS_BASE_WEIGHTS, KALLOS_DIMENSIONS } from '@/lib/sage/saga-os-v2.ts';
+
+export const SAGA_OS_V3_CORE_VERSION = "SAGA-OS v3 core (SYSTEM v14) — CATALOG-COMPILER · GENRE HELM v3 · ONOMASTRATA v3 · MORPHOGENESIS-LATTICE v2";
+export const CATALOG_VERSION = "empty-space v5+v6+v7 (package 2sagaco48 1.0.0)";
+export const RULE_TABLE_VERSION = "CA-rules v2 (B/S per genre) + morph v2 masks";
+export const GRAMMAR_PACK_VERSION = "controlled-en v1 (feature-unification, restricted)";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 0. SHA-256 (FIPS 180-4), synchronous, UTF-8 input → lowercase hex
+// ═══════════════════════════════════════════════════════════════════════════
+
+const K256 = new Uint32Array([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+
+function utf8Bytes(s: string): Uint8Array {
+  if (typeof TextEncoder !== "undefined") return new TextEncoder().encode(s);
+  const out: number[] = [];
+  for (let i = 0; i < s.length; i++) {
+    let c = s.charCodeAt(i);
+    if (c < 0x80) out.push(c);
+    else if (c < 0x800) out.push(0xc0 | (c >> 6), 0x80 | (c & 63));
+    else if (c >= 0xd800 && c < 0xdc00 && i + 1 < s.length) {
+      const d = s.charCodeAt(++i);
+      c = 0x10000 + ((c - 0xd800) << 10) + (d - 0xdc00);
+      out.push(0xf0 | (c >> 18), 0x80 | ((c >> 12) & 63), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));
+    } else out.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));
+  }
+  return Uint8Array.from(out);
+}
+
+export function sha256Hex(input: string): string {
+  const msg = utf8Bytes(input);
+  const bitLen = msg.length * 8;
+  const padLen = ((msg.length + 9 + 63) >> 6) << 6;
+  const buf = new Uint8Array(padLen);
+  buf.set(msg);
+  buf[msg.length] = 0x80;
+  const dv = new DataView(buf.buffer);
+  dv.setUint32(padLen - 8, Math.floor(bitLen / 0x100000000), false);
+  dv.setUint32(padLen - 4, bitLen >>> 0, false);
+
+  let h0 = 0x6a09e667, h1 = 0xbb67ae85, h2 = 0x3c6ef372, h3 = 0xa54ff53a,
+      h4 = 0x510e527f, h5 = 0x9b05688c, h6 = 0x1f83d9ab, h7 = 0x5be0cd19;
+  const w = new Uint32Array(64);
+  const rotr = (x: number, n: number) => (x >>> n) | (x << (32 - n));
+
+  for (let off = 0; off < padLen; off += 64) {
+    for (let i = 0; i < 16; i++) w[i] = dv.getUint32(off + i * 4, false);
+    for (let i = 16; i < 64; i++) {
+      const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3);
+      const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);
+      w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0;
+    }
+    let a = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g = h6, h = h7;
+    for (let i = 0; i < 64; i++) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = (e & f) ^ (~e & g);
+      const t1 = (h + S1 + ch + K256[i] + w[i]) >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = (a & b) ^ (a & c) ^ (b & c);
+      const t2 = (S0 + maj) >>> 0;
+      h = g; g = f; f = e; e = (d + t1) >>> 0; d = c; c = b; b = a; a = (t1 + t2) >>> 0;
+    }
+    h0 = (h0 + a) >>> 0; h1 = (h1 + b) >>> 0; h2 = (h2 + c) >>> 0; h3 = (h3 + d) >>> 0;
+    h4 = (h4 + e) >>> 0; h5 = (h5 + f) >>> 0; h6 = (h6 + g) >>> 0; h7 = (h7 + h) >>> 0;
+  }
+  return [h0, h1, h2, h3, h4, h5, h6, h7].map((x) => x.toString(16).padStart(8, "0")).join("");
+}
+
+/** Counter-based PRNG derived from a SeedGenome (v3 §11.1). No state beyond the counter. */
+export class GenomeRng {
+  private readonly k0: number;
+  private readonly k1: number;
+  private c = 0;
+  constructor(genomeHex: string) {
+    this.k0 = parseInt(genomeHex.slice(0, 8), 16) >>> 0;
+    this.k1 = parseInt(genomeHex.slice(8, 16), 16) >>> 0;
+  }
+  private static fmix(h: number): number {
+    h ^= h >>> 16; h = Math.imul(h, 0x85ebca6b);
+    h ^= h >>> 13; h = Math.imul(h, 0xc2b2ae35);
+    h ^= h >>> 16; return h >>> 0;
+  }
+  /** value at an explicit counter — order-independent, thread-safe by construction */
+  at(counter: number): number {
+    const a = GenomeRng.fmix((this.k0 ^ Math.imul(counter >>> 0, 0x9e3779b9)) >>> 0);
+    const b = GenomeRng.fmix((this.k1 + (counter >>> 0)) >>> 0);
+    return ((a ^ b) >>> 0) / 4294967296;
+  }
+  next(): number { this.c = (this.c + 1) >>> 0; return this.at(this.c); }
+  get counter(): number { return this.c; }
+  pick<T>(arr: readonly T[]): T { return arr[Math.floor(this.next() * arr.length)]; }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 1. CATALOG-COMPILER (§6)
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type WorldLayer = "W0" | "W1" | "W2" | "W3" | "W4" | "W5" | "W6" | "W7" | "W8" | "W9";
+export type SceneGrammarId =
+  | "ACTION" | "PROCESSING" | "INVESTIGATION" | "INSTITUTIONAL" | "MAINTENANCE"
+  | "RITUAL" | "TRAVEL" | "RELATIONAL" | "ENSEMBLE" | "AFTERMATH";
+export type ScreenChannel =
+  | "VISIBLE_ACTION" | "DIALOGUE" | "SUBTEXT" | "OBJECT_OR_PROP" | "VISUAL_MOTIF"
+  | "SOUND" | "REACTION_SHOT" | "VOICE_OVER" | "DREAM_OR_MEMORY" | "OMISSION_WITH_APPROVED_REASON";
+export type AudienceSegment = "adult" | "ya" | "children" | "literary" | "commercial";
+export type NameClass =
+  | "PERSON" | "DYNASTY" | "HOUSEHOLD" | "PLACE" | "REGION" | "INSTITUTION" | "OFFICE"
+  | "ARTIFACT" | "WEAPON" | "VEHICLE" | "SPECIES" | "EVENT" | "RITUAL" | "LAW"
+  | "DOCUMENT" | "WORK_TITLE" | "VOLUME_TITLE" | "CHAPTER_TITLE";
+
+export type CompiledElement = {
+  id: string;
+  sourceVersion: string;
+  sourceHash: string;
+  primarySlot: SlotClassId;
+  secondarySlots: SlotClassId[];
+  semanticDomain: string[];
+  preconditions: string[];
+  effects: string[];
+  conflictsWith: string[];
+  enables: string[];
+  worldLayers: WorldLayer[];
+  costAxes: CostAxis[];
+  stakesAxes: StakesAxis[];
+  sceneGrammars: SceneGrammarId[];
+  genreAffinity: Record<string, number>;
+  audienceAffinity: Record<AudienceSegment, number>;
+  nameRequirements: NameClass[];
+  realizationFrames: string[];
+  screenplayChannels: ScreenChannel[];
+  noveltyPrior: number;
+  playability: number;
+  harnessRequired: boolean;
+  provenanceStatus: "attested-clean" | "adjacent-differentiated" | "uncertain" | "band-inherited";
+  rowHash: string;
+  /** carried for prompt/UI use */
+  name: string;
+  desc: string;
+  band: string;
+};
+
+export type CatalogManifest = {
+  catalogVersion: string;
+  canonicalRows: number;
+  compiledRows: number;
+  failedClosed: { id: string; reason: string }[];
+  duplicateIdCount: number;
+  unresolvedSlotCount: number;
+  missingRealizationFrameCount: number;
+  coverage: number;                 // compiled / canonical
+  manifestHash: string;             // SHA-256 over sorted row hashes
+  releaseOk: boolean;               // §6.3 all four conditions
+  elements: CompiledElement[];
+  byId: Map<string, CompiledElement>;
+};
+
+const DOMAIN_RULES: [RegExp, string][] = [
+  [/\bwater|river|flood|tide|well|rain|drought|irrigat/i, "water"],
+  [/\bwaste|ash|landfill|sewage|garbage|refuse|rot\b/i, "waste"],
+  [/\bland|soil|field|farm|crop|harvest|acre|border/i, "land"],
+  [/\btime|clock|calendar|season|schedule|deadline|hour/i, "time"],
+  [/\blaw|court|rule|statute|verdict|jurisdiction|legal/i, "law"],
+  [/\bmemory|remember|forget|archive|record|ledger|receipt/i, "memory"],
+  [/\bfamily|kin|heir|inherit|generation|child|parent|lineage/i, "family"],
+  [/\blabou?r|work|repair|maintain|shift|wage|job/i, "labor"],
+  [/\bfaith|ritual|rite|sacred|temple|prayer|saint/i, "faith"],
+  [/\bwar|siege|soldier|weapon|battle|militia/i, "war"],
+  [/\btrade|market|price|debt|money|contract|bond|invoice/i, "trade"],
+  [/\bhealth|hospital|disease|medic|body|wound|illness/i, "health"],
+  [/\bmachine|engine|technolog|signal|system|network|device/i, "machine"],
+  [/\banimal|herd|beast|species|insect|bird|creature/i, "animal"],
+  [/\bweather|storm|wind|frost|heat|climate/i, "weather"],
+  [/\bname|title|office|rank|status|honou?r/i, "status"],
+];
+
+const LAYER_RULES: [RegExp, WorldLayer][] = [
+  [/physics|cosmolog|immutable|law of story|impossible/i, "W0"],
+  [/\blaw|statute|institution|contract|ritual|rule/i, "W1"],
+  [/money|water|food|energy|labou?r|legitimacy|attention|debt/i, "W2"],
+  [/place|route|border|jurisdiction|travel|map|distance/i, "W3"],
+  [/season|ecology|maintenance|weather|species|infrastructure|waste/i, "W4"],
+  [/kinship|taboo|language|grief|status|fashion|education/i, "W5"],
+  [/official|record|archive|claim/i, "W6"],
+  [/actually happened|witness|testimony|lived/i, "W7"],
+  [/rumou?r|belief|propaganda|myth|false/i, "W8"],
+  [/secret|hidden|conceal|unknown/i, "W9"],
+];
+
+const SLOT_GRAMMARS: Record<SlotClassId, SceneGrammarId[]> = {
+  "SC-A": ["ACTION", "RELATIONAL"], "SC-I": ["INSTITUTIONAL", "MAINTENANCE"], "SC-S": ["TRAVEL", "MAINTENANCE"],
+  "SC-T": ["ACTION", "PROCESSING"], "SC-B": ["PROCESSING", "ACTION"], "SC-L": ["RITUAL", "INSTITUTIONAL"],
+  "SC-R": ["RELATIONAL", "PROCESSING"], "SC-E": ["AFTERMATH"], "SC-G": ["ENSEMBLE", "ACTION"],
+  "SC-M": ["MAINTENANCE", "RITUAL"], "SC-N": ["PROCESSING"], "SC-W": ["INVESTIGATION"],
+  "SC-D": ["INVESTIGATION", "INSTITUTIONAL"], "SC-P": ["ACTION"],
+};
+const SLOT_FRAMES: Record<SlotClassId, string[]> = {
+  "SC-A": ["AGENT_ACTS_UNDER_CONSTRAINT", "AGENT_PAYS_COST"],
+  "SC-I": ["INSTITUTION_RULES", "INSTITUTION_EXACTS_OBLIGATION"],
+  "SC-S": ["PLACE_CONSTRAINS_ACTION", "PLACE_TRANSFORMS"],
+  "SC-T": ["DECISION_FORCED", "ALTERNATIVES_CLOSED"],
+  "SC-B": ["BEAT_TURN", "REACTION_THEN_DECISION"],
+  "SC-L": ["LAW_APPLIED_AT_EDGE", "EXCEPTION_PRICED"],
+  "SC-R": ["BOND_BID_AND_RESPONSE", "BOND_SHIFTS"],
+  "SC-E": ["CLOSURE_NAMES_RESIDUE", "SUCCESSOR_NAMED"],
+  "SC-G": ["MACRO_DRIVE_ESCALATES", "STRANDS_CONVERGE"],
+  "SC-M": ["MOTIF_RECURS_ALTERED", "THEME_LOCKS"],
+  "SC-N": ["FOCALIZATION_SHIFTS", "KNOWLEDGE_WITHHELD"],
+  "SC-W": ["REVEAL_REPRICES", "EVIDENCE_SURFACES"],
+  "SC-D": ["RECORD_CONSULTED", "CUSTODY_TRANSFERS"],
+  "SC-P": ["BRANCH_EXECUTED"],
+};
+const SLOT_CHANNELS: Record<SlotClassId, ScreenChannel[]> = {
+  "SC-A": ["VISIBLE_ACTION", "DIALOGUE", "REACTION_SHOT"], "SC-I": ["DIALOGUE", "OBJECT_OR_PROP", "VISIBLE_ACTION"],
+  "SC-S": ["VISUAL_MOTIF", "SOUND", "VISIBLE_ACTION"], "SC-T": ["VISIBLE_ACTION", "DIALOGUE"],
+  "SC-B": ["REACTION_SHOT", "SUBTEXT"], "SC-L": ["VISIBLE_ACTION", "OBJECT_OR_PROP"],
+  "SC-R": ["SUBTEXT", "REACTION_SHOT", "DIALOGUE"], "SC-E": ["VISUAL_MOTIF", "VISIBLE_ACTION"],
+  "SC-G": ["VISIBLE_ACTION", "SOUND"], "SC-M": ["VISUAL_MOTIF", "OBJECT_OR_PROP"],
+  "SC-N": ["SUBTEXT", "VOICE_OVER"], "SC-W": ["OBJECT_OR_PROP", "DIALOGUE", "REACTION_SHOT"],
+  "SC-D": ["OBJECT_OR_PROP", "DIALOGUE"], "SC-P": ["VISIBLE_ACTION"],
+};
+const SLOT_NAMES: Record<SlotClassId, NameClass[]> = {
+  "SC-A": ["PERSON"], "SC-I": ["INSTITUTION", "OFFICE"], "SC-S": ["PLACE", "REGION"], "SC-T": [],
+  "SC-B": [], "SC-L": ["LAW"], "SC-R": ["PERSON"], "SC-E": [], "SC-G": [], "SC-M": ["RITUAL"],
+  "SC-N": ["PERSON"], "SC-W": ["DOCUMENT", "ARTIFACT"], "SC-D": ["DOCUMENT"], "SC-P": ["EVENT"],
+};
+
+function audienceAffinityFor(tag: string, slot: SlotClassId, rarity: number): Record<AudienceSegment, number> {
+  const play = /\[play:H\]/i.test(tag) ? 0.9 : /\[play:M\]/i.test(tag) ? 0.6 : /\[play:L\]/i.test(tag) ? 0.3 : 0.5;
+  const literary = /\[adj:|\[rare\]/i.test(tag) ? 0.85 : 0.5 + rarity * 0.3;
+  return {
+    adult: 0.7,
+    ya: Math.min(1, 0.3 + play * 0.5),
+    children: Math.min(1, play * 0.6 * (slot === "SC-L" ? 0.6 : 1)),
+    literary: Math.min(1, literary),
+    commercial: Math.min(1, 0.4 + play * 0.4 + (slot === "SC-T" || slot === "SC-W" ? 0.2 : 0)),
+  };
+}
+
+let _manifest: CatalogManifest | null = null;
+
+/**
+ * §6.2 — compile every catalog row into a CompiledElement. FAIL CLOSED: any
+ * row with an unresolved mandatory field is excluded and listed, so coverage
+ * can only be 1.0 when every row is genuinely materialized (§6.3).
+ */
+export function compileCatalog(): CatalogManifest {
+  if (_manifest) return _manifest;
+  const wired = wireCatalog();
+  const nameIndex = wired.map((r) => ({ id: r.id, key: r.name.toLowerCase() }));
+  const seen = new Map<string, number>();
+  const failed: { id: string; reason: string }[] = [];
+  const elements: CompiledElement[] = [];
+  let unresolvedSlot = 0, missingFrames = 0;
+
+  for (const r of wired) {
+    seen.set(r.id, (seen.get(r.id) ?? 0) + 1);
+    const text = `${r.name} ${r.desc} ${r.tag}`;
+    const semanticDomain = DOMAIN_RULES.filter(([re]) => re.test(text)).map(([, d]) => d);
+    const worldLayers = [...new Set<WorldLayer>(LAYER_RULES.filter(([re]) => re.test(text)).map(([, l]) => l))];
+    if (!worldLayers.length) worldLayers.push(r.slotClass === "SC-S" ? "W3" : r.slotClass === "SC-I" ? "W1" : r.slotClass === "SC-L" ? "W0" : "W5");
+
+    // preconditions: slot-level + mechanism keywords
+    const pre = [...SLOT_PRECONDITIONS[r.slotClass].map((s) => `live:${s}`)];
+    if (/inherit|heir|succession/i.test(text)) pre.push("live:SC-D", "state:lineage-declared");
+    if (/verdict|ruling|court/i.test(text)) pre.push("live:SC-I");
+    if (/reveal|secret|discover/i.test(text)) pre.push("state:knowledge-asymmetry");
+    if (!pre.length) pre.push(r.slotClass === "SC-S" ? "context:ROOT_SETTING" : "context:BAND_DEFAULT");
+
+    const effects = [...SLOT_EFFECTS[r.slotClass]];
+    if (/debt|owe|price|cost/i.test(text)) effects.push("cost:debt+");
+    if (/repair|maintain/i.test(text)) effects.push("world:W4-drift-");
+    if (/split|fork|divide/i.test(text)) effects.push("relation:fork");
+
+    // conflicts: parse the catalog's own "≠ X" differentiators against row names
+    const conflicts: string[] = [];
+    const neq = [...r.tag.matchAll(/≠\s*([^;|\]\n]+)/g)].map((m) => m[1].trim().toLowerCase());
+    for (const phrase of neq) {
+      const hit = nameIndex.find((n) => n.id !== r.id && (n.key.includes(phrase) || phrase.includes(n.key)));
+      if (hit) conflicts.push(hit.id);
+    }
+    if (r.slotClass === "SC-L") conflicts.push("slot:SC-L(foreground>1)");
+
+    const enables: string[] = [];
+    if (/succession|handoff|successor/i.test(text)) enables.push("ending:Handoff", "ending:Successor");
+    if (/audit|ledger|record|archive/i.test(text)) enables.push("slot:SC-D");
+    if (/converge|shared|compact|treaty/i.test(text)) enables.push("grammar:ENSEMBLE");
+    if (/reveal|evidence|clue/i.test(text)) enables.push("slot:SC-W");
+    if (!enables.length) enables.push(`slot:${r.slotClass}`);
+
+    const stakesAxes: StakesAxis[] = [r.stakesAxis];
+    if (/moral|guilt|shame/i.test(text) && !stakesAxes.includes("moral")) stakesAxes.push("moral");
+    if (/institution|office|bureau/i.test(text) && !stakesAxes.includes("institutional")) stakesAxes.push("institutional");
+    const costAxes: CostAxis[] = [r.costAxis];
+    if (/body|wound|illness/i.test(text) && !costAxes.includes("body")) costAxes.push("body");
+    if (/debt|price/i.test(text) && !costAxes.includes("debt")) costAxes.push("debt");
+
+    const sceneGrammars = [...SLOT_GRAMMARS[r.slotClass]];
+    if (/investigat|evidence|search/i.test(text) && !sceneGrammars.includes("INVESTIGATION")) sceneGrammars.push("INVESTIGATION");
+    if (/aftermath|grief|residue/i.test(text) && !sceneGrammars.includes("AFTERMATH")) sceneGrammars.push("AFTERMATH");
+
+    const frames = [...SLOT_FRAMES[r.slotClass]];
+    const provenance: CompiledElement["provenanceStatus"] =
+      /\[clean\]/i.test(r.tag) ? "attested-clean" : /\[adj:/i.test(r.tag) ? "adjacent-differentiated"
+      : /\[unc\]|\[assum\]/i.test(r.tag) ? "uncertain" : "band-inherited";
+
+    // ── fail-closed gate (§6.2 "require at least")
+    const reasons: string[] = [];
+    if (!r.slotClass) reasons.push("no primary slot");
+    if (!pre.length) reasons.push("no precondition/enabling context");
+    if (!effects.length && !costAxes.length) reasons.push("no effect or cost");
+    if (!sceneGrammars.length) reasons.push("no scene grammar");
+    if (!Object.keys(r.genreAffinity).length) reasons.push("no genre affinity");
+    if (!frames.length) { reasons.push("no realization frame"); missingFrames++; }
+    if (!r.slotClass) unresolvedSlot++;
+    if (reasons.length) { failed.push({ id: r.id, reason: reasons.join("; ") }); continue; }
+
+    const sourceHash = sha256Hex(`${r.id}|${r.name}|${r.desc}|${r.tag}`).slice(0, 16);
+    const el: CompiledElement = {
+      id: r.id, sourceVersion: CATALOG_VERSION, sourceHash,
+      primarySlot: r.slotClass, secondarySlots: r.secondaryClasses, semanticDomain,
+      preconditions: pre, effects, conflictsWith: conflicts, enables, worldLayers,
+      costAxes, stakesAxes, sceneGrammars,
+      genreAffinity: r.genreAffinity,
+      audienceAffinity: audienceAffinityFor(r.tag, r.slotClass, r.rarity),
+      nameRequirements: SLOT_NAMES[r.slotClass],
+      realizationFrames: frames, screenplayChannels: SLOT_CHANNELS[r.slotClass],
+      noveltyPrior: r.rarity, playability: r.play ? 0.75 : 0.5,
+      harnessRequired: r.harnessRequired, provenanceStatus: provenance,
+      rowHash: "", name: r.name, desc: r.desc, band: r.band,
+    };
+    el.rowHash = sha256Hex(JSON.stringify({ ...el, rowHash: undefined })).slice(0, 16);
+    elements.push(el);
+  }
+
+  const duplicateIdCount = [...seen.values()].filter((n) => n > 1).length;
+  const coverage = wired.length ? elements.length / wired.length : 0;
+  const manifestHash = sha256Hex(elements.map((e) => e.rowHash).sort().join(""));
+  _manifest = {
+    catalogVersion: CATALOG_VERSION, canonicalRows: wired.length, compiledRows: elements.length,
+    failedClosed: failed, duplicateIdCount, unresolvedSlotCount: unresolvedSlot,
+    missingRealizationFrameCount: missingFrames, coverage, manifestHash,
+    releaseOk: coverage === 1 && duplicateIdCount === 0 && unresolvedSlot === 0 && missingFrames === 0,
+    elements, byId: new Map(elements.map((e) => [e.id, e])),
+  };
+  return _manifest;
+}
+
+// ── §6.4 runtime selection ──────────────────────────────────────────────────
+
+export type SelectionContext = {
+  seed: string;                      // genome hex (or any string) for tie-break
+  vacantSlot: SlotClassId;
+  genreFamily: string;
+  audience: AudienceSegment;
+  liveSlots: Set<SlotClassId>;       // for precondition satisfaction
+  activeStakes: StakesAxis | null;
+  readerLoadBudget: number;          // 0..1 remaining
+  activeIds: Set<string>;            // for conflicts + repetition
+  activeBands: string[];             // recent bands, most recent last
+  bandUsage: Map<string, number>;    // usage counts → underused bonus
+  noveltyNeed: number;               // 0..1
+  loopLoad: number;                  // 0..1 open-loop pressure
+  castLoad: number;                  // 0..1 of ≤15 window
+};
+
+export type SelectionResult = {
+  chosen: CompiledElement | null;
+  candidates: number;
+  scored: { id: string; score: number; auditRisk: number; unresolvedCost: number }[];
+  reason: string;
+};
+
+/** §6.4 — candidate intersection, ranking, and deterministic tie-break. */
+export function selectCompiledElement(ctx: SelectionContext): SelectionResult {
+  const m = compileCatalog();
+  const cands = m.elements.filter((e) =>
+    e.primarySlot === ctx.vacantSlot &&
+    !ctx.activeIds.has(e.id) &&
+    (e.genreAffinity[ctx.genreFamily] ?? 0) >= 0.4 &&
+    (ctx.activeStakes == null || e.stakesAxes.includes(ctx.activeStakes) || e.stakesAxes.length > 1) &&
+    !e.conflictsWith.some((c) => ctx.activeIds.has(c)) &&
+    !(e.harnessRequired && ctx.liveSlots.has("SC-L")) &&
+    (e.audienceAffinity[ctx.audience] ?? 0) >= 0.25,
+  );
+  const pool = cands.length ? cands : m.elements.filter((e) => e.primarySlot === ctx.vacantSlot && !ctx.activeIds.has(e.id));
+  if (!pool.length) return { chosen: null, candidates: 0, scored: [], reason: "no candidate for slot" };
+
+  const scored = pool.map((e) => {
+    const preLive = e.preconditions.filter((p) => p.startsWith("live:"));
+    const causalFit = preLive.length ? preLive.filter((p) => ctx.liveSlots.has(p.slice(5) as SlotClassId)).length / preLive.length : 0.7;
+    const genreFit = e.genreAffinity[ctx.genreFamily] ?? 0.3;
+    const audFit = e.audienceAffinity[ctx.audience] ?? 0.4;
+    const novelty = e.noveltyPrior * ctx.noveltyNeed;
+    const motif = e.stakesAxes.includes(ctx.activeStakes as StakesAxis) ? 0.3 : 0;
+    const kallosLocal = 0.5 * novelty + 0.5 * (1 - ctx.castLoad);
+    const usage = ctx.bandUsage.get(e.band) ?? 0;
+    const underused = 1 / (1 + usage);
+    const repetition = ctx.activeBands.slice(-2).filter((b) => b === e.band).length * 0.5;
+    const cognitive = (1 - ctx.readerLoadBudget) * 0.6;
+    const score = causalFit + genreFit + audFit + novelty + motif + kallosLocal + underused
+                - ctx.castLoad - ctx.loopLoad - repetition - cognitive;
+    const auditRisk = (e.harnessRequired ? 0.5 : 0) + (e.provenanceStatus === "uncertain" ? 0.3 : 0) + e.conflictsWith.length * 0.05;
+    const unresolvedCost = e.costAxes.length * 0.1 + (e.preconditions.length - preLive.length) * 0.05;
+    return { id: e.id, score, auditRisk, unresolvedCost };
+  });
+  scored.sort((a, b) =>
+    b.score - a.score || a.auditRisk - b.auditRisk || a.unresolvedCost - b.unresolvedCost ||
+    (sha256Hex(`${ctx.seed}||${a.id}`) < sha256Hex(`${ctx.seed}||${b.id}`) ? -1 : 1));
+  return { chosen: m.byId.get(scored[0].id) ?? null, candidates: pool.length, scored: scored.slice(0, 8),
+    reason: cands.length ? "intersection non-empty" : "fell back to slot-only pool (genre/audience filter exhausted)" };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 2. GENRE HELM v3 (§7)
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type ToneWord = "intimate" | "cool" | "warm" | "dread" | "wry" | "plain" | "charged" | "wonder";
+export type Trajectory = "darkening" | "lightening" | "steady" | "oscillating" | "collapsing" | "converging";
+export type EndingTone = "bittersweet" | "earned" | "tragic" | "open" | "custodial" | "triumphant" | "quiet";
+
+export type BuildRequest = {
+  project: {
+    medium: "novel" | "novella" | "short" | "serial" | "screenplay";
+    language: "en";
+    length: { volumes: number; wordsPerVolume: number };
+    seed: number;
+  };
+  creative: {
+    genres: string[];                 // 1..3 keys; mix weights derive from order unless given
+    mixWeights?: number[];
+    subgenres: string[];
+    audience: {
+      ageBand: "children" | "middle_grade" | "ya" | "adult";
+      heatLevel: "none" | "low" | "moderate" | "high";
+      violenceLevel: "none" | "low" | "moderate" | "high";
+      readingComplexity: "accessible" | "accessible_literary" | "literary" | "dense";
+    };
+    tone: { opening: ToneWord; trajectory: Trajectory; ending: EndingTone };
+    requests: { protagonist?: string; setting?: string; relationship?: string; premise?: string };
+  };
+};
+
+export type GenreProfile = {
+  key: string;
+  family: string;                   // GENRE_HELM family for slot/element affinity
+  kallosKey: keyof typeof KALLOS_BASE_WEIGHTS | string;
+  dominantReaderQuestion: string;
+  expectedPleasures: string[];
+  mandatoryPayoffs: string[];
+  forbiddenFailures: string[];
+  defaultEndingFamilies: string[];
+  stakesWeights: Partial<Record<StakesAxis, number>>;
+  pacingWeights: { spike: number; relief: number; dread: number; intimacy: number };
+  sceneGrammarWeights: Partial<Record<SceneGrammarId, number>>;
+  proseRegister: string;
+  nameRegister: string;
+};
+
+export const GENRE_PROFILES: Record<string, GenreProfile> = {
+  romance: {
+    key: "romance", family: "ROMANCE", kallosKey: "romance",
+    dominantReaderQuestion: "Will these two people become able to choose each other, and at what cost to who they were?",
+    expectedPleasures: ["charged proximity", "misread signals", "earned vulnerability", "the declaration scene"],
+    mandatoryPayoffs: ["central relationship receives explicit closure", "each lead changes because of the other"],
+    forbiddenFailures: ["romantic lead is secretly nonexistent", "relationship resolved by coincidence", "one lead is punished for the other's growth"],
+    defaultEndingFamilies: ["Handoff", "Maintenance", "Ring"],
+    stakesWeights: { relational: 0.45, identity: 0.3, moral: 0.15 },
+    pacingWeights: { spike: 0.3, relief: 0.6, dread: 0.2, intimacy: 0.9 },
+    sceneGrammarWeights: { RELATIONAL: 0.4, PROCESSING: 0.25, ACTION: 0.15 },
+    proseRegister: "warm, close-third, sensory, interiority-forward", nameRegister: "PERSON: euphonic, distinct initials; PLACE: lived-in",
+  },
+  psychological_thriller: {
+    key: "psychological_thriller", family: "THRILLER", kallosKey: "mystery_thriller",
+    dominantReaderQuestion: "Whose account of what is happening can be trusted, and what will believing it cost?",
+    expectedPleasures: ["destabilised trust", "the reread clue", "the ticking constraint", "reversal that recontextualises"],
+    mandatoryPayoffs: ["threat mystery is causally resolved", "every misdirection is fair on reread"],
+    forbiddenFailures: ["it was all a dream/hallucination unless licensed", "villain omniscience", "clue introduced only in the reveal"],
+    defaultEndingFamilies: ["Verdict", "Split-custody", "Decommission"],
+    stakesWeights: { epistemic: 0.4, physical: 0.25, identity: 0.2 },
+    pacingWeights: { spike: 0.8, relief: 0.3, dread: 0.8, intimacy: 0.3 },
+    sceneGrammarWeights: { INVESTIGATION: 0.35, ACTION: 0.25, PROCESSING: 0.2 },
+    proseRegister: "tight, present-tense-capable, withholding, concrete", nameRegister: "PERSON: short, plausible; INSTITUTION: flat and official",
+  },
+  mystery: {
+    key: "mystery", family: "MYSTERY", kallosKey: "mystery_thriller",
+    dominantReaderQuestion: "What actually happened, and who had reason and means?",
+    expectedPleasures: ["fair-play clues", "method", "the investigator's cost", "the assembled truth"],
+    mandatoryPayoffs: ["solution follows from on-page evidence", "investigator pays a personal price for knowing"],
+    forbiddenFailures: ["culprit not present before the final quarter", "evidence withheld from the reader that the detective had"],
+    defaultEndingFamilies: ["Verdict", "Audit", "Custodial"],
+    stakesWeights: { epistemic: 0.45, moral: 0.25, institutional: 0.2 },
+    pacingWeights: { spike: 0.5, relief: 0.4, dread: 0.5, intimacy: 0.3 },
+    sceneGrammarWeights: { INVESTIGATION: 0.45, INSTITUTIONAL: 0.2, PROCESSING: 0.2 },
+    proseRegister: "observant, procedural, dry", nameRegister: "PERSON: distinct by syllable count; DOCUMENT: numbered",
+  },
+  horror: {
+    key: "horror", family: "HORROR", kallosKey: "horror",
+    dominantReaderQuestion: "What is wrong with this place, and will anyone be allowed to leave it changed rather than destroyed?",
+    expectedPleasures: ["dread accumulation", "the rule you cannot break", "institutional complicity", "power reversal"],
+    mandatoryPayoffs: ["the source of dread receives a confrontation", "survivor bears a named residue"],
+    forbiddenFailures: ["threat explained away as hoax without cost", "unearned rescue", "gore substituting for dread"],
+    defaultEndingFamilies: ["Decommission", "Counterfactual-closure", "Residual"],
+    stakesWeights: { physical: 0.35, identity: 0.3, moral: 0.2 },
+    pacingWeights: { spike: 0.7, relief: 0.35, dread: 1, intimacy: 0.4 },
+    sceneGrammarWeights: { ACTION: 0.3, RITUAL: 0.2, PROCESSING: 0.2, AFTERMATH: 0.15 },
+    proseRegister: "flat declarative under pressure, sensory, patient", nameRegister: "PLACE: plain and ominous; INSTITUTION: benevolent-sounding",
+  },
+  fantasy: {
+    key: "fantasy", family: "FANTASY", kallosKey: "fantasy",
+    dominantReaderQuestion: "What does this world's rule cost, and who is made to pay it?",
+    expectedPleasures: ["progressive world revelation", "the priced exception", "alliance under pressure", "wonder with consequence"],
+    mandatoryPayoffs: ["every world-rule exception is priced on page", "map/knowledge expands and returns transformed"],
+    forbiddenFailures: ["magic solves a problem it was not established to solve", "prophecy replaces decision"],
+    defaultEndingFamilies: ["Handoff", "Custodial", "Ring"],
+    stakesWeights: { physical: 0.25, institutional: 0.25, custodial: 0.25, moral: 0.15 },
+    pacingWeights: { spike: 0.6, relief: 0.5, dread: 0.4, intimacy: 0.5 },
+    sceneGrammarWeights: { ACTION: 0.25, TRAVEL: 0.2, RITUAL: 0.15, ENSEMBLE: 0.15 },
+    proseRegister: "concrete wonder, grounded texture, low exposition", nameRegister: "PERSON/PLACE: single coherent phonology, declared contact layers only",
+  },
+  romantasy: {
+    key: "romantasy", family: "FANTASY", kallosKey: "romantasy",
+    dominantReaderQuestion: "Can the bond survive the world's rule, and which will bend first?",
+    expectedPleasures: ["bond tested by world stakes", "alliance/rivalry heat", "series escalation", "established-world return"],
+    mandatoryPayoffs: ["relationship and world plot each move irreversibly", "bond is chosen under cost, not fated"],
+    forbiddenFailures: ["bond resolved by prophecy", "world stakes reset between volumes"],
+    defaultEndingFamilies: ["Handoff", "Open-serial", "Ring"],
+    stakesWeights: { relational: 0.35, physical: 0.25, institutional: 0.2 },
+    pacingWeights: { spike: 0.7, relief: 0.5, dread: 0.4, intimacy: 0.8 },
+    sceneGrammarWeights: { RELATIONAL: 0.3, ACTION: 0.3, ENSEMBLE: 0.15 },
+    proseRegister: "high-heat close-third, kinetic", nameRegister: "PERSON: strong distinct initials; DYNASTY/HOUSEHOLD registers",
+  },
+  science_fiction: {
+    key: "science_fiction", family: "SF", kallosKey: "science_fiction",
+    dominantReaderQuestion: "What does this system do to the people inside it, and who notices first?",
+    expectedPleasures: ["premise worked out rigorously", "institutional critique", "the diagnostic turn", "consequence at scale"],
+    mandatoryPayoffs: ["premise's second-order consequence is dramatized", "system change has aftermath in ordinary life"],
+    forbiddenFailures: ["technology exception at the climax", "lecture replacing scene"],
+    defaultEndingFamilies: ["Decommission", "Handoff", "Reform"],
+    stakesWeights: { epistemic: 0.3, institutional: 0.3, ecological: 0.2 },
+    pacingWeights: { spike: 0.5, relief: 0.4, dread: 0.5, intimacy: 0.3 },
+    sceneGrammarWeights: { INVESTIGATION: 0.25, INSTITUTIONAL: 0.25, MAINTENANCE: 0.2 },
+    proseRegister: "precise, cool, specific nouns", nameRegister: "INSTITUTION/OFFICE: bureaucratic; ARTIFACT: numbered",
+  },
+  literary: {
+    key: "literary", family: "LITERARY", kallosKey: "general_fiction",
+    dominantReaderQuestion: "What does it cost to keep living honestly inside this arrangement?",
+    expectedPleasures: ["interiority with consequence", "the small irreversible decision", "texture of labour and money", "unresolved but named residue"],
+    mandatoryPayoffs: ["at least one irreversible private decision changes a relationship", "residue is named, not resolved away"],
+    forbiddenFailures: ["spectacle substituting for pressure", "epiphany without cost"],
+    defaultEndingFamilies: ["Maintenance", "Stable-Incomplete", "Residual"],
+    stakesWeights: { relational: 0.3, moral: 0.3, custodial: 0.2 },
+    pacingWeights: { spike: 0.25, relief: 0.5, dread: 0.3, intimacy: 0.8 },
+    sceneGrammarWeights: { PROCESSING: 0.3, RELATIONAL: 0.25, MAINTENANCE: 0.2 },
+    proseRegister: "exact, unhurried, image-true", nameRegister: "PERSON: ordinary, era-plausible",
+  },
+  institutional_maintenance: {
+    key: "institutional_maintenance", family: "LITERARY", kallosKey: "institutional_maintenance",
+    dominantReaderQuestion: "Who keeps this running, what does it quietly cost them, and who inherits the duty?",
+    expectedPleasures: ["procedure as drama", "the repair that reveals", "custodial handoff", "anti-spectacle"],
+    mandatoryPayoffs: ["custody/duty is explicitly transferred or refused", "a maintenance failure has a visible aftermath"],
+    forbiddenFailures: ["heroic rescue replacing maintenance", "institution becomes a villain instead of a system"],
+    defaultEndingFamilies: ["Maintenance", "Custodial", "Handoff"],
+    stakesWeights: { institutional: 0.35, custodial: 0.35, ecological: 0.15 },
+    pacingWeights: { spike: 0.2, relief: 0.5, dread: 0.4, intimacy: 0.5 },
+    sceneGrammarWeights: { MAINTENANCE: 0.35, INSTITUTIONAL: 0.3, AFTERMATH: 0.15 },
+    proseRegister: "plain, procedural, precise units", nameRegister: "INSTITUTION/OFFICE/DOCUMENT registers dominant",
+  },
+  historical: {
+    key: "historical", family: "HISTORICAL", kallosKey: "historical",
+    dominantReaderQuestion: "What did it feel like to be inside this moment before its outcome was known?",
+    expectedPleasures: ["richly drawn period", "professional and personal stakes braided", "known outcome, unknown cost"],
+    mandatoryPayoffs: ["period constraint shapes at least one decisive choice", "personal and public stakes converge"],
+    forbiddenFailures: ["anachronistic expertise or values without cost", "period as wallpaper"],
+    defaultEndingFamilies: ["Custodial", "Ring", "Residual"],
+    stakesWeights: { institutional: 0.3, moral: 0.25, identity: 0.25 },
+    pacingWeights: { spike: 0.4, relief: 0.5, dread: 0.4, intimacy: 0.6 },
+    sceneGrammarWeights: { INSTITUTIONAL: 0.25, RELATIONAL: 0.25, TRAVEL: 0.15 },
+    proseRegister: "plain to charged, period-plausible diction", nameRegister: "PERSON: attested-era register; PLACE: real or era-consistent",
+  },
+  family_saga: {
+    key: "family_saga", family: "FAMILY/SAGA", kallosKey: "general_fiction",
+    dominantReaderQuestion: "What passes down, what refuses to, and who ends up holding it?",
+    expectedPleasures: ["generational echo", "inheritance with strings", "the house/farm/shop as character"],
+    mandatoryPayoffs: ["at least one inheritance is accepted, refused, or transformed on page", "a pattern repeats with a changed cost"],
+    forbiddenFailures: ["generations as reskins", "secret revealed with no downstream consequence"],
+    defaultEndingFamilies: ["Handoff", "Successor", "Custodial"],
+    stakesWeights: { custodial: 0.35, relational: 0.3, identity: 0.2 },
+    pacingWeights: { spike: 0.3, relief: 0.5, dread: 0.3, intimacy: 0.7 },
+    sceneGrammarWeights: { RELATIONAL: 0.3, AFTERMATH: 0.2, RITUAL: 0.15 },
+    proseRegister: "layered, patient, object-anchored", nameRegister: "DYNASTY/HOUSEHOLD lineage system active",
+  },
+  ya: {
+    key: "ya", family: "CHILDREN/YA", kallosKey: "ya_saga",
+    dominantReaderQuestion: "Who am I allowed to become here, and who decides?",
+    expectedPleasures: ["identity under institutional pressure", "friendship as engine", "clear local danger with wonder", "hometown/known-world reinterpretation"],
+    mandatoryPayoffs: ["protagonist makes a choice an adult would not have let them make", "friendship changes state"],
+    forbiddenFailures: ["adult solves the climax", "moralising narration"],
+    defaultEndingFamilies: ["Handoff", "Ring", "Open-serial"],
+    stakesWeights: { identity: 0.35, relational: 0.3, physical: 0.2 },
+    pacingWeights: { spike: 0.6, relief: 0.6, dread: 0.4, intimacy: 0.6 },
+    sceneGrammarWeights: { ACTION: 0.3, RELATIONAL: 0.3, PROCESSING: 0.15 },
+    proseRegister: "clear, immediate, voice-forward", nameRegister: "PERSON: short, memorable, distinct initials",
+  },
+  comedy: {
+    key: "comedy", family: "COMEDY", kallosKey: "general_fiction",
+    dominantReaderQuestion: "How long can this arrangement pretend to work?",
+    expectedPleasures: ["escalating confusion", "institution as farce", "the dignified collapse", "reintegration"],
+    mandatoryPayoffs: ["confusion resolves by recognition, not by accident alone", "the institution's logic is exposed"],
+    forbiddenFailures: ["cruelty without recognition", "punchlines replacing decisions"],
+    defaultEndingFamilies: ["Ring", "Maintenance", "Reform"],
+    stakesWeights: { institutional: 0.35, relational: 0.3, identity: 0.2 },
+    pacingWeights: { spike: 0.5, relief: 0.8, dread: 0.1, intimacy: 0.5 },
+    sceneGrammarWeights: { INSTITUTIONAL: 0.3, ENSEMBLE: 0.25, RELATIONAL: 0.2 },
+    proseRegister: "dry, exact timing, escalating specificity", nameRegister: "OFFICE/INSTITUTION: over-formal; PERSON: plain",
+  },
+};
+
+/** Fuzzy genre key resolver (accepts "psychological_thiller", "sci-fi", "thriller", …). */
+export function resolveGenreKey(raw: string): string | null {
+  const k = raw.toLowerCase().replace(/[\s-]+/g, "_");
+  if (GENRE_PROFILES[k]) return k;
+  const alias: Record<string, string> = {
+    thriller: "psychological_thriller", psychological_thiller: "psychological_thriller", psych_thriller: "psychological_thriller",
+    sf: "science_fiction", sci_fi: "science_fiction", scifi: "science_fiction",
+    saga: "family_saga", family: "family_saga", generational: "family_saga",
+    young_adult: "ya", children: "ya", middle_grade: "ya",
+    maintenance: "institutional_maintenance", institutional: "institutional_maintenance",
+    general_fiction: "literary", literary_fiction: "literary",
+    romantic_suspense: "romance", gothic_romance: "romance", cozy: "mystery", procedural: "mystery",
+    satire: "comedy", farce: "comedy",
+  };
+  if (alias[k]) return alias[k];
+  const hit = Object.keys(GENRE_PROFILES).find((g) => g.includes(k) || k.includes(g));
+  return hit ?? null;
+}
+
+export type GenreContract = {
+  dominant: GenreProfile;
+  secondary: GenreProfile[];
+  mix: { key: string; weight: number }[];
+  dominantReaderQuestion: string;
+  expectedPleasures: string[];
+  mandatoryPayoffs: string[];
+  forbiddenFailures: string[];
+  defaultEndingFamilies: string[];
+  stakesWeights: Partial<Record<StakesAxis, number>>;
+  pacingWeights: GenreProfile["pacingWeights"];
+  sceneGrammarWeights: Partial<Record<SceneGrammarId, number>>;
+  proseRegister: string;
+  nameRegister: string;
+  kallosBaseWeights: number[];          // 12 dims, sums to 100
+  audienceSegment: AudienceSegment;
+  audienceConstraints: string[];
+  toneContract: string[];
+  subgenres: string[];
+  unresolved: string[];                 // genres that could not be resolved — declared, not dropped silently
+  family: string;                       // dominant GENRE_HELM family (drives slot/element affinity)
+};
+
+/** §7.2–7.3 — blend genres into one contract. Σ mix weights = 1 by construction. */
+export function compileGenreContract(req: BuildRequest): GenreContract {
+  const resolved: { key: string; weight: number }[] = [];
+  const unresolved: string[] = [];
+  req.creative.genres.forEach((g, i) => {
+    const key = resolveGenreKey(g);
+    if (!key) { unresolved.push(g); return; }
+    const w = req.creative.mixWeights?.[i];
+    resolved.push({ key, weight: w != null && w > 0 ? w : Math.max(0.15, 1 / (i + 1)) });
+  });
+  if (!resolved.length) resolved.push({ key: "literary", weight: 1 });
+  const sum = resolved.reduce((a, x) => a + x.weight, 0);
+  const mix = resolved.map((x) => ({ key: x.key, weight: Math.round((x.weight / sum) * 1000) / 1000 }));
+  mix.sort((a, b) => b.weight - a.weight);
+  const dominant = GENRE_PROFILES[mix[0].key];
+  const secondary = mix.slice(1).map((x) => GENRE_PROFILES[x.key]);
+
+  // KALLOS base weights = Σ w_i × profile_i (row re-normalised to 100)
+  const dims = KALLOS_DIMENSIONS.length;
+  const kw = new Array<number>(dims).fill(0);
+  for (const x of mix) {
+    const row = KALLOS_BASE_WEIGHTS[GENRE_PROFILES[x.key].kallosKey] ?? KALLOS_BASE_WEIGHTS.general_fiction;
+    for (let i = 0; i < dims; i++) kw[i] += x.weight * row[i];
+  }
+  const kwSum = kw.reduce((a, b) => a + b, 0) || 1;
+  const kallosBaseWeights = kw.map((v) => Math.round((v / kwSum) * 1000) / 10);
+
+  const stakes: Partial<Record<StakesAxis, number>> = {};
+  for (const x of mix) for (const [k, v] of Object.entries(GENRE_PROFILES[x.key].stakesWeights)) {
+    stakes[k as StakesAxis] = (stakes[k as StakesAxis] ?? 0) + x.weight * (v ?? 0);
+  }
+  const grammars: Partial<Record<SceneGrammarId, number>> = {};
+  for (const x of mix) for (const [k, v] of Object.entries(GENRE_PROFILES[x.key].sceneGrammarWeights)) {
+    grammars[k as SceneGrammarId] = (grammars[k as SceneGrammarId] ?? 0) + x.weight * (v ?? 0);
+  }
+  const pacing = { spike: 0, relief: 0, dread: 0, intimacy: 0 };
+  for (const x of mix) { const p = GENRE_PROFILES[x.key].pacingWeights; pacing.spike += x.weight * p.spike; pacing.relief += x.weight * p.relief; pacing.dread += x.weight * p.dread; pacing.intimacy += x.weight * p.intimacy; }
+
+  const aud = req.creative.audience;
+  const audienceSegment: AudienceSegment =
+    aud.ageBand === "children" || aud.ageBand === "middle_grade" ? "children"
+    : aud.ageBand === "ya" ? "ya"
+    : aud.readingComplexity === "literary" || aud.readingComplexity === "dense" ? "literary"
+    : "adult";
+  const audienceConstraints = [
+    `age band ${aud.ageBand}`,
+    aud.heatLevel === "none" ? "no on-page sexual content" : `heat level ${aud.heatLevel}`,
+    aud.violenceLevel === "none" ? "no on-page violence" : `violence level ${aud.violenceLevel}`,
+    `reading complexity ${aud.readingComplexity}`,
+    ...(audienceSegment === "children" ? ["no graphic harm to children on page", "adult does not solve the climax"] : []),
+  ];
+  const t = req.creative.tone;
+  const toneContract = [
+    `opening register: ${t.opening}`,
+    `trajectory: ${t.trajectory}`,
+    `ending tone: ${t.ending}`,
+    t.trajectory === "darkening" ? "each act must remove one comfort the previous act allowed" :
+    t.trajectory === "lightening" ? "each act must pay one debt the previous act incurred" :
+    t.trajectory === "converging" ? "strands must share a cause or a cost by the final quarter" :
+    t.trajectory === "collapsing" ? "the governing institution loses authority in visible steps" :
+    t.trajectory === "oscillating" ? "alternate pressure and relief at sequence scale, not scene scale" :
+    "hold the opening register; change stakes, not temperature",
+  ];
+
+  return {
+    dominant, secondary, mix,
+    dominantReaderQuestion: dominant.dominantReaderQuestion,
+    expectedPleasures: [...dominant.expectedPleasures, ...secondary.flatMap((s) => s.expectedPleasures.slice(0, 2))],
+    mandatoryPayoffs: [...dominant.mandatoryPayoffs, ...secondary.flatMap((s) => s.mandatoryPayoffs.slice(0, 1))],
+    forbiddenFailures: [...new Set([...dominant.forbiddenFailures, ...secondary.flatMap((s) => s.forbiddenFailures)])],
+    defaultEndingFamilies: dominant.defaultEndingFamilies,
+    stakesWeights: stakes, pacingWeights: pacing, sceneGrammarWeights: grammars,
+    proseRegister: dominant.proseRegister, nameRegister: dominant.nameRegister,
+    kallosBaseWeights, audienceSegment, audienceConstraints, toneContract,
+    subgenres: req.creative.subgenres, unresolved, family: dominant.family,
+  };
+}
+
+/** Default request used when the studio has not composed one. */
+export function defaultBuildRequest(seed: number, family?: string): BuildRequest {
+  const familyToKey: Record<string, string> = {
+    ROMANCE: "romance", THRILLER: "psychological_thriller", MYSTERY: "mystery", HORROR: "horror", FANTASY: "fantasy",
+    SF: "science_fiction", LITERARY: "literary", HISTORICAL: "historical", "FAMILY/SAGA": "family_saga",
+    "CHILDREN/YA": "ya", COMEDY: "comedy",
+  };
+  return {
+    project: { medium: "novel", language: "en", length: { volumes: 1, wordsPerVolume: 60000 }, seed },
+    creative: {
+      genres: [familyToKey[family ?? ""] ?? "literary"], subgenres: [],
+      audience: { ageBand: "adult", heatLevel: "low", violenceLevel: "moderate", readingComplexity: "accessible_literary" },
+      tone: { opening: "plain", trajectory: "darkening", ending: "bittersweet" },
+      requests: {},
+    },
+  };
+}
+
+export const BUILD_REQUEST_KEY = "veritas.saga.buildRequest.v1";
+export function loadBuildRequest(): BuildRequest | null {
+  try { const raw = localStorage.getItem(BUILD_REQUEST_KEY); return raw ? (JSON.parse(raw) as BuildRequest) : null; } catch { return null; }
+}
+export function saveBuildRequest(req: BuildRequest | null): void {
+  try { if (req) localStorage.setItem(BUILD_REQUEST_KEY, JSON.stringify(req)); else localStorage.removeItem(BUILD_REQUEST_KEY); } catch { /* optional */ }
+}
+
+/** GENRE_HELM (v2 taxonomy) leaves available for a resolved family — for the studio form. */
+export function subgenresFor(genreKey: string): string[] {
+  const p = GENRE_PROFILES[genreKey];
+  return p ? (GENRE_HELM[p.family] ?? []) : [];
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 3. ONOMASTRATA v3 (§10)
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type NameCultureProfile = {
+  profileId: string;
+  script: "Latn";
+  locale: string;
+  onsets: [string, number][];        // weighted
+  nuclei: [string, number][];
+  codas: [string, number][];
+  syllableTemplates: [string, number][]; // "CV" | "CVC" | "V" | "VC" | "CCV" | "CVCC"
+  stress: "initial" | "penultimate" | "final";
+  vowelHarmony?: { front: string[]; back: string[] };
+  morphemes: { root: string; meaning: string; classes: NameClass[] }[];
+  lineage: "patronymic-suffix" | "house-prefix" | "none" | "matronymic-suffix";
+  lineageAffix: string;
+  honorifics: string[];
+  tabooSequences: string[];
+  nameOrder: "given-first" | "surname-first";
+  nicknameRule: "first-syllable+diminutive" | "last-syllable" | "clipped";
+  diminutive: string;
+  historicalLayers: { id: string; soundChanges: [RegExp, string][] }[];
+  contactEvent?: string;             // required for hybrids (§10.5)
+};
+
+const P = (xs: string[], w = 1): [string, number][] => xs.map((x) => [x, w]);
+
+export const NAME_PROFILES: Record<string, NameCultureProfile> = {
+  RIVERINE: {
+    profileId: "RIVERINE", script: "Latn", locale: "x-riverine",
+    onsets: [...P(["m", "n", "l", "r", "s", "v", "th", "h"], 2), ...P(["d", "t", "k", "b"], 1)],
+    nuclei: [...P(["a", "e", "i", "o"], 2), ...P(["ae", "ei", "ou", "ia"], 1)],
+    codas: [...P(["n", "l", "r", "s"], 2), ...P(["th", "nd", "m"], 1)],
+    syllableTemplates: [["CV", 4], ["CVC", 3], ["V", 1], ["VC", 1]],
+    stress: "penultimate", vowelHarmony: { front: ["e", "i", "ei", "ia"], back: ["a", "o", "ou", "ae"] },
+    morphemes: [
+      { root: "mer", meaning: "river-bend", classes: ["PLACE", "REGION"] }, { root: "lin", meaning: "reed", classes: ["PLACE", "PERSON"] },
+      { root: "sol", meaning: "ford", classes: ["PLACE"] }, { root: "ael", meaning: "keeper", classes: ["PERSON", "OFFICE"] },
+      { root: "thar", meaning: "weir", classes: ["PLACE", "INSTITUTION"] }, { root: "ven", meaning: "tally", classes: ["DOCUMENT", "ARTIFACT"] },
+    ],
+    lineage: "patronymic-suffix", lineageAffix: "-sen", honorifics: ["Keeper", "Warden", "Elder"],
+    tabooSequences: ["kk", "xx", "gh"], nameOrder: "given-first", nicknameRule: "first-syllable+diminutive", diminutive: "i",
+    historicalLayers: [{ id: "old-riverine", soundChanges: [[/t(?=[aeiou])/g, "d"], [/s$/g, "z"]] }],
+  },
+  HIGHLAND: {
+    profileId: "HIGHLAND", script: "Latn", locale: "x-highland",
+    onsets: [...P(["br", "dr", "gr", "kr", "st", "sk", "th", "w"], 2), ...P(["b", "d", "g", "k", "h", "r"], 1)],
+    nuclei: [...P(["a", "e", "o", "u"], 2), ...P(["ei", "au"], 1)],
+    codas: [...P(["ck", "ld", "rn", "th", "st", "rk"], 2), ...P(["n", "r", "d"], 1)],
+    syllableTemplates: [["CVC", 4], ["CCVC", 3], ["CV", 1], ["CVCC", 2]],
+    stress: "initial",
+    morphemes: [
+      { root: "brack", meaning: "scree", classes: ["PLACE", "PERSON"] }, { root: "hold", meaning: "fortified", classes: ["PLACE", "DYNASTY"] },
+      { root: "dorn", meaning: "thorn", classes: ["PERSON", "WEAPON"] }, { root: "garth", meaning: "yard", classes: ["PLACE", "HOUSEHOLD"] },
+      { root: "wick", meaning: "settlement", classes: ["PLACE"] }, { root: "rune", meaning: "counsel", classes: ["OFFICE", "INSTITUTION"] },
+    ],
+    lineage: "house-prefix", lineageAffix: "of ", honorifics: ["Reeve", "Thane", "Marshal"],
+    tabooSequences: ["ll", "ss"], nameOrder: "given-first", nicknameRule: "clipped", diminutive: "",
+    historicalLayers: [{ id: "old-highland", soundChanges: [[/ck$/g, "k"], [/w/g, "hw"]] }],
+  },
+  SALTMARCH: {
+    profileId: "SALTMARCH", script: "Latn", locale: "x-saltmarch",
+    onsets: [...P(["f", "v", "s", "sh", "z", "l", "y"], 2), ...P(["m", "n", "h"], 1)],
+    nuclei: [...P(["a", "i", "u", "e"], 2), ...P(["ai", "ui", "oa"], 1)],
+    codas: [...P(["s", "sh", "l", "n"], 2), ...P(["f", "z"], 1)],
+    syllableTemplates: [["CV", 4], ["CVC", 2], ["V", 2], ["CVV", 1]],
+    stress: "final",
+    morphemes: [
+      { root: "sal", meaning: "salt", classes: ["PLACE", "INSTITUTION"] }, { root: "fen", meaning: "marsh", classes: ["PLACE", "REGION"] },
+      { root: "ysa", meaning: "gull", classes: ["PERSON"] }, { root: "voel", meaning: "net", classes: ["ARTIFACT", "PERSON"] },
+      { root: "shai", meaning: "tide-mark", classes: ["EVENT", "RITUAL"] },
+    ],
+    lineage: "matronymic-suffix", lineageAffix: "-dotter", honorifics: ["Netmother", "Pilot", "Tidewarden"],
+    tabooSequences: ["pp", "kk", "tt"], nameOrder: "surname-first", nicknameRule: "last-syllable", diminutive: "",
+    historicalLayers: [{ id: "old-saltmarch", soundChanges: [[/f/g, "ph"], [/y/g, "j"]] }],
+  },
+  ARCHIVAL: {
+    profileId: "ARCHIVAL", script: "Latn", locale: "x-archival",
+    onsets: [...P(["c", "p", "t", "r", "m", "s", "v", "l"], 2), ...P(["qu", "gn", "d"], 1)],
+    nuclei: [...P(["a", "e", "i", "o", "u"], 2)],
+    codas: [...P(["s", "m", "n", "r", "x"], 2), ...P(["nt", "rs"], 1)],
+    syllableTemplates: [["CV", 3], ["CVC", 3], ["V", 1]],
+    stress: "penultimate",
+    morphemes: [
+      { root: "regis", meaning: "register", classes: ["INSTITUTION", "DOCUMENT"] }, { root: "custod", meaning: "custody", classes: ["OFFICE", "INSTITUTION"] },
+      { root: "tabul", meaning: "tablet", classes: ["DOCUMENT", "ARTIFACT"] }, { root: "mensur", meaning: "measure", classes: ["LAW", "ARTIFACT"] },
+      { root: "provis", meaning: "provision", classes: ["LAW", "DOCUMENT"] }, { root: "sigill", meaning: "seal", classes: ["ARTIFACT", "OFFICE"] },
+    ],
+    lineage: "none", lineageAffix: "", honorifics: ["Registrar", "Assessor", "Adjudicator", "Custodian"],
+    tabooSequences: ["kk", "zz"], nameOrder: "given-first", nicknameRule: "clipped", diminutive: "",
+    historicalLayers: [],
+  },
+  CANTON: {
+    profileId: "CANTON", script: "Latn", locale: "x-canton",
+    onsets: [...P(["k", "t", "p", "m", "n", "l", "h", "s"], 2), ...P(["ch", "ts"], 1)],
+    nuclei: [...P(["a", "i", "u", "o"], 2), ...P(["aa", "ii", "uu"], 1)],
+    codas: [...P(["n", "ng", "k", "t"], 2), ...P(["m"], 1)],
+    syllableTemplates: [["CV", 4], ["CVC", 3], ["CVV", 1]],
+    stress: "initial",
+    morphemes: [
+      { root: "kan", meaning: "district", classes: ["PLACE", "REGION", "INSTITUTION"] }, { root: "tul", meaning: "gate", classes: ["PLACE", "PERSON"] },
+      { root: "min", meaning: "grain", classes: ["INSTITUTION", "EVENT"] }, { root: "hosa", meaning: "hearth", classes: ["HOUSEHOLD", "PERSON"] },
+      { root: "nuk", meaning: "boundary-stone", classes: ["ARTIFACT", "LAW"] },
+    ],
+    lineage: "house-prefix", lineageAffix: "", honorifics: ["Headman", "Gatekeeper", "Elder"],
+    tabooSequences: ["rr", "ll", "th"], nameOrder: "surname-first", nicknameRule: "first-syllable+diminutive", diminutive: "ko",
+    historicalLayers: [{ id: "old-canton", soundChanges: [[/ng$/g, "n"], [/ts/g, "s"]] }],
+  },
+};
+
+/** §10.5 — a hybrid must declare the contact event that explains the mixture. */
+export function hybridProfile(a: string, b: string, contactEvent: string, id?: string): NameCultureProfile {
+  const A = NAME_PROFILES[a], B = NAME_PROFILES[b];
+  if (!A || !B) throw new Error(`hybridProfile: unknown profile ${!A ? a : b}`);
+  if (!contactEvent || contactEvent.trim().length < 12) throw new Error("hybridProfile: a declared historical contact event (≥12 chars) is mandatory (§10.5)");
+  return {
+    ...A, profileId: id ?? `${a}+${b}`, contactEvent,
+    onsets: [...A.onsets, ...B.onsets.map(([s, w]) => [s, w * 0.5] as [string, number])],
+    codas: [...A.codas, ...B.codas.map(([s, w]) => [s, w * 0.5] as [string, number])],
+    morphemes: [...A.morphemes, ...B.morphemes],
+    honorifics: [...A.honorifics, ...B.honorifics],
+    tabooSequences: [...new Set([...A.tabooSequences, ...B.tabooSequences])],
+    historicalLayers: [...A.historicalLayers, ...B.historicalLayers],
+  };
+}
+
+function weightedPick(rng: GenomeRng, xs: [string, number][]): string {
+  const total = xs.reduce((a, [, w]) => a + w, 0);
+  let x = rng.next() * total;
+  for (const [s, w] of xs) { x -= w; if (x <= 0) return s; }
+  return xs[xs.length - 1][0];
+}
+
+function syllable(rng: GenomeRng, p: NameCultureProfile, harmony: "front" | "back" | null): string {
+  const tpl = weightedPick(rng, p.syllableTemplates);
+  let nuc = weightedPick(rng, p.nuclei);
+  if (harmony && p.vowelHarmony) {
+    const set = p.vowelHarmony[harmony];
+    const allowed = p.nuclei.filter(([n]) => set.includes(n));
+    if (allowed.length) nuc = weightedPick(rng, allowed);
+  }
+  let out = "";
+  for (const ch of tpl) {
+    if (ch === "C") out += weightedPick(rng, out.length === 0 ? p.onsets : p.codas);
+    else if (ch === "V") out += nuc;
+  }
+  return out;
+}
+
+const VOWELS_RE = /[aeiou]/g;
+export function syllableCount(s: string): number {
+  const clean = s.toLowerCase().replace(/[^a-z]/g, "");
+  if (!clean) return 0;
+  const m = clean.match(/[aeiouy]+/g);
+  return m ? m.length : 1;
+}
+function stressIndex(p: NameCultureProfile, n: number): number {
+  return p.stress === "initial" ? 0 : p.stress === "final" ? n - 1 : Math.max(0, n - 2);
+}
+
+/** UTS#39-style skeleton: fold visually confusable Latin sequences to a canonical form. */
+export function confusableSkeleton(s: string): string {
+  return s.toLowerCase()
+    .replace(/rn/g, "m").replace(/vv/g, "w").replace(/cl/g, "d").replace(/[l1|]/g, "i")
+    .replace(/0/g, "o").replace(/5/g, "s").replace(/[fi]/g, "fi").replace(/ph/g, "f")
+    .replace(/ck/g, "k").replace(/[^a-z]/g, "");
+}
+
+/** Metaphone-lite phonetic key for collision detection. */
+export function phoneticKey(s: string): string {
+  let t = s.toLowerCase().replace(/[^a-z]/g, "");
+  if (!t) return "";
+  const first = t[0];
+  t = t.slice(1).replace(VOWELS_RE, "")
+    .replace(/[bp]/g, "P").replace(/[dt]/g, "T").replace(/[kcq]/g, "K").replace(/[sz]/g, "S")
+    .replace(/[fv]/g, "F").replace(/[mn]/g, "N").replace(/[lr]/g, "R").replace(/[gj]/g, "J")
+    .replace(/(.)\1+/g, "$1");
+  return (first + t).slice(0, 6);
+}
+function editDistance(a: string, b: string): number {
+  const d = Array.from({ length: a.length + 1 }, (_, i) => [i, ...new Array(b.length).fill(0)]);
+  for (let j = 0; j <= b.length; j++) d[0][j] = j;
+  for (let i = 1; i <= a.length; i++) for (let j = 1; j <= b.length; j++)
+    d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+  return d[a.length][b.length];
+}
+
+export type GeneratedName = {
+  nameClass: NameClass;
+  profileId: string;
+  full: string;                      // CLDR-ordered display form
+  given: string;
+  family: string | null;
+  short: string;
+  formal: string;
+  addressing: string;
+  referring: string;
+  nickname: string;
+  alias: string | null;
+  semanticPayload: string;
+  syllables: number;
+  stressOn: number;
+  skeleton: string;
+  phonetic: string;
+  layer: string | null;
+};
+
+export type NameRegistry = {
+  reserved: Map<string, GeneratedName>;
+  rejections: { candidate: string; reason: string }[];
+};
+export function createNameRegistry(): NameRegistry { return { reserved: new Map(), rejections: [] }; }
+
+const REAL_NAME_DENYLIST = ["harry potter", "hermione granger", "frodo baggins", "katniss everdeen", "sherlock holmes", "jane eyre", "elizabeth bennet", "jay gatsby"];
+
+function titleCase1(s: string): string { return s ? s[0].toUpperCase() + s.slice(1) : s; }
+
+/**
+ * §10.3 — the twelve-step pipeline. Deterministic given (rng, profile, class,
+ * registry). Steps 8–12 are the audits; a candidate that fails any is logged
+ * in `registry.rejections` and regenerated (bounded attempts).
+ */
+export function generateName(
+  rng: GenomeRng, profile: NameCultureProfile, nameClass: NameClass, registry: NameRegistry,
+  opts?: { payload?: string; layer?: string | null; maxAttempts?: number },
+): GeneratedName | null {
+  const maxAttempts = opts?.maxAttempts ?? 72;
+  const activePeople = [...registry.reserved.values()].filter((n) => n.nameClass === "PERSON");
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    // 1. semantic payload
+    const roots = profile.morphemes.filter((m) => m.classes.includes(nameClass));
+    const root = roots.length && rng.next() < 0.6 ? rng.pick(roots) : null;
+    const payload = opts?.payload ?? root?.meaning ?? "unmarked";
+    // 2–3. morphemes + phonological form
+    const harmony: "front" | "back" | null = profile.vowelHarmony ? (rng.next() < 0.5 ? "front" : "back") : null;
+    // Syllable target varies 1–4 for PERSON so the §10.4 syllable+stress rule
+    // has room to be satisfied; stem growth is capped by LETTERS as well as
+    // syllables because diphthong nuclei + codas overshoot ("Asaeourtha").
+    const nSyl = nameClass === "PERSON" ? 1 + Math.floor(rng.next() * 4) : 2 + Math.floor(rng.next() * 2);
+    const maxLen = nameClass === "PERSON" ? 8 : 9;
+    let stem = root ? root.root : "";
+    let guard = 0;
+    while ((stem.length === 0 || syllableCount(stem) < nSyl) && stem.length < maxLen && guard++ < 8) stem += syllable(rng, profile, harmony);
+    if (stem.length < 3) stem += syllable(rng, profile, harmony);
+    if (stem.length > maxLen + 2) stem = stem.slice(0, maxLen + 2).replace(/[^aeiou]+$/, (m) => m.slice(0, 2));
+    // 4. historical sound change layer
+    const layer = opts?.layer === undefined ? (profile.historicalLayers.length && rng.next() < 0.25 ? profile.historicalLayers[0] : null) : profile.historicalLayers.find((l) => l.id === opts.layer) ?? null;
+    if (layer) for (const [re, rep] of layer.soundChanges) stem = stem.replace(re, rep);
+    stem = stem.replace(/(.)\1{2,}/g, "$1$1");
+    // 5. morphology / lineage
+    let given = titleCase1(stem);
+    let family: string | null = null;
+    if (nameClass === "PERSON" || nameClass === "DYNASTY" || nameClass === "HOUSEHOLD") {
+      const fam = titleCase1(syllable(rng, profile, harmony) + syllable(rng, profile, harmony));
+      family = profile.lineage === "patronymic-suffix" || profile.lineage === "matronymic-suffix" ? fam + profile.lineageAffix
+        : profile.lineage === "house-prefix" ? (profile.lineageAffix + fam).trim() : fam;
+    }
+    if (nameClass === "INSTITUTION") given = `The ${rng.pick(["Office", "Registry", "Board", "Company", "Wardens", "Court", "Trust"])} of ${given}`;
+    if (nameClass === "OFFICE") given = `${rng.pick(profile.honorifics)} ${given}`;
+    if (nameClass === "LAW") given = `The ${given} ${rng.pick(["Provision", "Measure", "Ordinance", "Compact", "Rule"])}`;
+    if (nameClass === "DOCUMENT") given = `The ${given} ${rng.pick(["Ledger", "Schedule", "Deed", "Census", "Warrant"])}`;
+    if (nameClass === "ARTIFACT") given = `The ${given} ${rng.pick(["Seal", "Tally", "Key", "Standard", "Chain"])}`;
+    if (nameClass === "EVENT" || nameClass === "RITUAL") given = `The ${given} ${rng.pick(["Reckoning", "Drawing", "Counting", "Walk", "Watch"])}`;
+    if (nameClass === "WORK_TITLE" || nameClass === "VOLUME_TITLE" || nameClass === "CHAPTER_TITLE") given = `${rng.pick(["The", "After", "Under", "Before"])} ${given}`;
+    // 6. CLDR-compatible field ordering
+    const full = family
+      ? (profile.nameOrder === "given-first" ? `${given} ${family}` : `${family} ${given}`)
+      : given;
+    // 7. forms
+    const nick = profile.nicknameRule === "first-syllable+diminutive"
+      ? titleCase1((stem.match(/^[^aeiou]*[aeiou]+[^aeiou]?/)?.[0] ?? stem.slice(0, 3)) + profile.diminutive)
+      : profile.nicknameRule === "last-syllable" ? titleCase1(stem.slice(-3))
+      : titleCase1(stem.slice(0, Math.max(3, Math.ceil(stem.length / 2))));
+    const honor = profile.honorifics[Math.floor(rng.next() * profile.honorifics.length)];
+    const cand: GeneratedName = {
+      nameClass, profileId: profile.profileId, full, given, family,
+      short: given, formal: family ? `${honor} ${family.replace(/^of /, "")}` : given,
+      addressing: nameClass === "PERSON" ? given : full, referring: full,
+      nickname: nameClass === "PERSON" ? nick : given, alias: null,
+      semanticPayload: payload, syllables: syllableCount(given), stressOn: stressIndex(profile, syllableCount(given)),
+      skeleton: confusableSkeleton(given), phonetic: phoneticKey(given), layer: layer?.id ?? null,
+    };
+    // 8. visual confusable audit  9. phonetic collision  10. taboo  11. real-name denylist  12. reserve
+    const low = full.toLowerCase();
+    // taboo applies to GENERATED phonology (given stem + family stem), not to
+    // lineage affixes or honorific scaffolding — "-dotter" must not trip "tt".
+    const generated = `${stem} ${family ? family.replace(profile.lineageAffix, "") : ""}`.toLowerCase();
+    let reason: string | null = null;
+    if (registry.reserved.has(low)) reason = "duplicate";
+    else if (profile.tabooSequences.some((t) => generated.includes(t))) reason = `taboo sequence`;
+    else if (REAL_NAME_DENYLIST.some((d) => low.includes(d))) reason = "real-name denylist";
+    else if (nameClass === "PERSON") {
+      const clash = activePeople.find((n) => n.skeleton === cand.skeleton || n.phonetic === cand.phonetic ||
+        editDistance(n.given.toLowerCase(), given.toLowerCase()) / Math.max(n.given.length, given.length) < 0.35 ||
+        n.nickname.toLowerCase() === cand.nickname.toLowerCase());
+      if (clash) reason = `collides with ${clash.given} (skeleton/phonetic/edit/nickname)`;
+      else if (activePeople.filter((n) => n.given[0].toLowerCase() === given[0].toLowerCase()).length >= 2) reason = `first letter "${given[0]}" already used twice`;
+      else if (activePeople.filter((n) => n.syllables === cand.syllables && n.stressOn === cand.stressOn).length >= 3) reason = `syllable+stress pattern ${cand.syllables}:${cand.stressOn} already matches 3 leads`;
+    }
+    if (reason) { registry.rejections.push({ candidate: full, reason }); continue; }
+    registry.reserved.set(low, cand);
+    return cand;
+  }
+  return null;
+}
+
+export type CastConfusionV3Finding = { rule: string; a: string; b: string; detail: string };
+/** §10.4 — all six rules over a set of major names (strings or GeneratedName). */
+export function auditCastConfusionV3(names: (string | GeneratedName)[], profile?: NameCultureProfile): CastConfusionV3Finding[] {
+  const N = names.map((n) => typeof n === "string" ? n : n.given);
+  const f: CastConfusionV3Finding[] = [];
+  const byInitial = new Map<string, string[]>();
+  for (const n of N) { const k = n[0]?.toLowerCase() ?? ""; byInitial.set(k, [...(byInitial.get(k) ?? []), n]); }
+  for (const [k, g] of byInitial) if (g.length > 2) f.push({ rule: "first-letter ≤2", a: g[0], b: g.slice(1).join(", "), detail: `${g.length} major names begin with "${k}"` });
+  const stressSig = (n: string) => `${syllableCount(n)}:${profile ? stressIndex(profile, syllableCount(n)) : 0}`;
+  const sigCount = new Map<string, string[]>();
+  for (const n of N) sigCount.set(stressSig(n), [...(sigCount.get(stressSig(n)) ?? []), n]);
+  for (const [sig, g] of sigCount) if (g.length > 3) f.push({ rule: "syllable+stress ≤3 matches", a: g[0], b: g.slice(1).join(", "), detail: `${g.length} leads share pattern ${sig}` });
+  for (let i = 0; i < N.length; i++) for (let j = i + 1; j < N.length; j++) {
+    const a = N[i], b = N[j];
+    const nd = editDistance(a.toLowerCase(), b.toLowerCase()) / Math.max(a.length, b.length, 1);
+    if (nd < 0.35) f.push({ rule: "normalized edit distance ≥0.35", a, b, detail: `distance ${nd.toFixed(2)}` });
+    if (phoneticKey(a) === phoneticKey(b)) f.push({ rule: "phonetic distance ≥ threshold", a, b, detail: `both key to ${phoneticKey(a)}` });
+    if (confusableSkeleton(a) === confusableSkeleton(b)) f.push({ rule: "confusable skeleton must differ", a, b, detail: `skeleton ${confusableSkeleton(a)}` });
+  }
+  const gens = names.filter((n): n is GeneratedName => typeof n !== "string");
+  for (let i = 0; i < gens.length; i++) for (let j = i + 1; j < gens.length; j++)
+    if (gens[i].nickname.toLowerCase() === gens[j].nickname.toLowerCase()) f.push({ rule: "nickname collision forbidden", a: gens[i].given, b: gens[j].given, detail: `both → ${gens[i].nickname}` });
+  return f;
+}
+
+/** Generate a full cast + world name set for a build, one profile, deterministic. */
+export function generateNameSet(genomeHex: string, profileId: string, counts: Partial<Record<NameClass, number>>): { names: GeneratedName[]; registry: NameRegistry; audit: CastConfusionV3Finding[] } {
+  const profile = NAME_PROFILES[profileId] ?? NAME_PROFILES.RIVERINE;
+  const rng = new GenomeRng(sha256Hex(`onoma|${genomeHex}|${profile.profileId}`));
+  const registry = createNameRegistry();
+  const names: GeneratedName[] = [];
+  for (const [cls, n] of Object.entries(counts) as [NameClass, number][]) {
+    for (let i = 0; i < (n ?? 0); i++) { const g = generateName(rng, profile, cls, registry); if (g) names.push(g); }
+  }
+  return { names, registry, audit: auditCastConfusionV3(names.filter((n) => n.nameClass === "PERSON"), profile) };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 4. MORPHOGENESIS-LATTICE v2 (§11)
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type LatticeScale = "WORLD" | "CAST" | "PLOT" | "DISCOURSE" | "SERIES";
+export type NarrativeCell = {
+  cellId: string;
+  scale: LatticeScale;
+  state: "DORMANT" | "ACTIVE" | "RETIRED";
+  boundElementId: string | null;
+  owner: string;                     // entity row id
+  kind: EntityKind;
+  preconditions: string[];
+  effects: string[];
+  neighbors: string[];
+  activeCosts: CostAxis[];
+  activePromises: string[];
+  targetAttractor: GenesisPattern | null;
+  birthTick: number;
+  lastTick: number;
+};
+export type TypedDelta = { tick: number; from: LatticeScale; to: LatticeScale; kind: string; detail: string; cellId: string };
+export type Promise_ = { id: string; scope: "LOCAL" | "PHASE" | "SAGA"; openedTick: number; ownerCell: string; state: "SEEDED" | "PAID" | "TRANSFERRED" | "EXPIRED" | "RESIDUALIZED"; closedTick: number | null };
+export type MorphCheckpoint = { tick: number; hash: string; population: number; promisesOpen: number };
+export type LengthMode = "flash" | "short" | "novel" | "saga" | "serial";
+
+export type MorphRun = {
+  genome: string;
+  userSeed: number;
+  lengthMode: LengthMode;
+  budgetTicks: number;
+  cells: NarrativeCell[];
+  ticks: GridTick[];
+  stateHashes: string[];
+  checkpoints: MorphCheckpoint[];
+  deltas: TypedDelta[];
+  promises: Promise_[];
+  attractor: GenesisPattern;
+  attractorDetail: string;
+  attractorInTarget: boolean;
+  endingFamily: string;
+  targetAttractors: GenesisPattern[];
+  volumes: { index: number; startTick: number; endTick: number; localClosure: boolean; seriesDelta: string }[];
+  births: { tick: number; cellId: string; elementId: string; score: number; reason: string }[];
+  masked: { tick: number; cellId: string; elementId: string; rule: string }[];
+  compressionAdvice: string[];
+  scenes: { index: number; tick: number; cellId: string; owner: string; kind: EntityKind; element: CompiledElement | null; grammar: SceneGrammarId; stakes: StakesAxis; cost: CostAxis; interior: boolean; volume: number; chapter: number }[];
+  chapters: { index: number; volume: number; scenes: number; intensity: number; dominantStakes: StakesAxis | null }[];
+  stats: { births: number; deaths: number; distinctElements: number; slotsExercised: number; castLoadMax: number; loopDebtMax: number };
+};
+
+const ENDING_TO_ATTRACTOR: Record<string, GenesisPattern[]> = {
+  Maintenance: ["STILL-LIFE"], "Stable-Incomplete": ["STILL-LIFE"], Residual: ["STILL-LIFE", "METHUSELAH"],
+  Handoff: ["GLIDER"], Custodial: ["GLIDER"], Successor: ["GLIDER"], "Open-serial": ["GLIDER-GUN"], Reform: ["GLIDER", "RING"],
+  Tragedy: ["EXTINCTION"], Decommission: ["EXTINCTION"], "Counterfactual-closure": ["EXTINCTION"],
+  Ring: ["RING"], "Split-custody": ["SPLIT"], Verdict: ["STILL-LIFE", "RING"], Audit: ["STILL-LIFE"], Episodic: ["OSCILLATOR"],
+};
+
+export function deriveSeedGenome(x: { userSeed: number; genre: GenreContract; audience: AudienceSegment; targetLength: number }): string {
+  return sha256Hex([
+    String(x.userSeed >>> 0),
+    JSON.stringify({ mix: x.genre.mix, family: x.genre.family, end: x.genre.defaultEndingFamilies }),
+    x.audience, String(x.targetLength), CATALOG_VERSION, RULE_TABLE_VERSION, GRAMMAR_PACK_VERSION,
+  ].join("||"));
+}
+
+export type MorphOpts = {
+  userSeed: number;
+  contract: GenreContract;
+  spec: GenreSpec;                   // v2 GenreSpec for the CA rule table + topology
+  lengthMode?: LengthMode;
+  targetWords?: number;
+  budget?: number;
+  audience?: AudienceSegment;
+};
+
+const SLOT_FOR_KIND: Record<EntityKind, SlotClassId[]> = {
+  agent: ["SC-A", "SC-R", "SC-N", "SC-M"],
+  institution: ["SC-I", "SC-D", "SC-L"],
+  setting: ["SC-S", "SC-L"],
+  strand: ["SC-T", "SC-B", "SC-W", "SC-G", "SC-E"],
+};
+const SCALE_FOR_KIND: Record<EntityKind, LatticeScale> = { agent: "CAST", institution: "WORLD", setting: "WORLD", strand: "PLOT" };
+
+/**
+ * §11.4 evolution. Legal births come from CATALOG-COMPILER via §6.4 selection
+ * (genre/audience/precondition/conflict-aware); audit masks zero out illegal
+ * births (≤1 foreground LAW, cast window ≤15, loop debt, reader-load); winners
+ * are ranked by causal + genre + audience + KALLOS_local + underused − load −
+ * loop_debt − repetition; effects propagate as TYPED DELTAS between lattices;
+ * attractor is detected each tick and matched against the contract's target
+ * ending families; every tick is checkpointed by content hash.
+ */
+export function runMorphogenesis(opts: MorphOpts): MorphRun {
+  const contract = opts.contract;
+  const audience = opts.audience ?? contract.audienceSegment;
+  const lengthMode: LengthMode = opts.lengthMode ?? (opts.spec.V >= 13 ? "serial" : opts.spec.V >= 2 ? "saga" : (opts.targetWords ?? 60000) < 8000 ? "short" : "novel");
+  const targetWords = opts.targetWords ?? 60000;
+  const genome = deriveSeedGenome({ userSeed: opts.userSeed, genre: contract, audience, targetLength: targetWords });
+  const rng = new GenomeRng(genome);
+  const budget = Math.max(6, Math.min(120, opts.budget ??
+    (lengthMode === "flash" ? 8 : lengthMode === "short" ? 14 : lengthMode === "novel" ? 40 : lengthMode === "saga" ? 72 : 96)));
+  const targetAttractors = [...new Set(contract.defaultEndingFamilies.flatMap((e) => ENDING_TO_ATTRACTOR[e] ?? []))];
+  const manifest = compileCatalog();
+
+  // topology from v2 (same seed family so v2 grid and v3 lattice describe one world)
+  const rows: EntityRow[] = buildRows(opts.spec, opts.userSeed >>> 0);
+  const byRow = new Map(rows.map((r) => [r.id, r]));
+  const cells: NarrativeCell[] = rows.map((r) => ({
+    cellId: `${SCALE_FOR_KIND[r.kind]}:${r.id}`, scale: SCALE_FOR_KIND[r.kind], state: "DORMANT", boundElementId: null,
+    owner: r.id, kind: r.kind, preconditions: [], effects: [], neighbors: [], activeCosts: [], activePromises: [],
+    targetAttractor: targetAttractors[0] ?? null, birthTick: -1, lastTick: -1,
+  }));
+  const cellByOwner = new Map(cells.map((c) => [c.owner, c]));
+  const neighboursOf = (rowId: string): string[] => {
+    const r = byRow.get(rowId); if (!r) return [];
+    const out = new Set<string>(r.relations);
+    for (const s of r.settings) for (const o of rows) if (o.id !== rowId && o.settings.includes(s)) out.add(o.id);
+    return [...out];
+  };
+  for (const c of cells) c.neighbors = neighboursOf(c.owner).map((id) => cellByOwner.get(id)?.cellId ?? id);
+
+  const deltas: TypedDelta[] = [];
+  const promises: Promise_[] = [];
+  const births: MorphRun["births"] = [];
+  const masked: MorphRun["masked"] = [];
+  const checkpoints: MorphCheckpoint[] = [];
+  const ticks: GridTick[] = [];
+  const hashes: string[] = [];
+  const activeIds = new Set<string>();
+  const bandUsage = new Map<string, number>();
+  const recentBands: string[] = [];
+  const B = opts.spec.caRuleTableId.includes("LITERARY") || opts.spec.caRuleTableId.includes("DOMESTIC") ? [3, 4] : [3];
+  const S = opts.spec.caRuleTableId.includes("LITERARY") || opts.spec.caRuleTableId.includes("DOMESTIC") ? [2, 3, 4] : [2, 3];
+  let castLoadMax = 0, loopDebtMax = 0, deaths = 0;
+  let lawLive = 0;   // foreground LAW count, updated by bind/retire so intra-tick births are masked too
+  const stakesOrder = (Object.entries(contract.stakesWeights) as [StakesAxis, number][]).sort((a, b) => b[1] - a[1]).map(([k]) => k);
+
+  const bind = (cell: NarrativeCell, el: CompiledElement, tick: number, score: number, reason: string) => {
+    cell.state = "ACTIVE"; cell.boundElementId = el.id; cell.birthTick = tick; cell.lastTick = tick;
+    cell.preconditions = el.preconditions; cell.effects = el.effects; cell.activeCosts = el.costAxes;
+    if (el.harnessRequired) lawLive++;
+    activeIds.add(el.id); bandUsage.set(el.band, (bandUsage.get(el.band) ?? 0) + 1); recentBands.push(el.band);
+    births.push({ tick, cellId: cell.cellId, elementId: el.id, score, reason });
+    // typed deltas: PLOT births open promises; WORLD births change layers; CAST births change relations
+    if (cell.scale === "PLOT" && (el.primarySlot === "SC-T" || el.primarySlot === "SC-W" || el.primarySlot === "SC-G")) {
+      const pid = `P${promises.length + 1}`;
+      promises.push({ id: pid, scope: lengthMode === "saga" || lengthMode === "serial" ? (rng.next() < 0.3 ? "SAGA" : "PHASE") : "LOCAL", openedTick: tick, ownerCell: cell.cellId, state: "SEEDED", closedTick: null });
+      cell.activePromises.push(pid);
+      deltas.push({ tick, from: "PLOT", to: "SERIES", kind: "promise-opened", detail: `${pid} ${el.name}`, cellId: cell.cellId });
+    }
+    if (cell.scale === "WORLD") deltas.push({ tick, from: "WORLD", to: "PLOT", kind: "world-layer", detail: `${el.worldLayers.join("/")} via ${el.name}`, cellId: cell.cellId });
+    if (cell.scale === "CAST") deltas.push({ tick, from: "CAST", to: "PLOT", kind: el.primarySlot === "SC-R" ? "relation-delta" : "intention", detail: el.name, cellId: cell.cellId });
+    deltas.push({ tick, from: cell.scale, to: "DISCOURSE", kind: "scene-stub", detail: `${el.sceneGrammars[0]} · ${el.name}`, cellId: cell.cellId });
+  };
+  const retire = (cell: NarrativeCell, tick: number, how: "isolation" | "overcrowd") => {
+    cell.state = "RETIRED"; cell.lastTick = tick; deaths++;
+    if (cell.boundElementId) {
+      if (manifest.byId.get(cell.boundElementId)?.harnessRequired) lawLive = Math.max(0, lawLive - 1);
+      activeIds.delete(cell.boundElementId);
+    }
+    for (const pid of cell.activePromises) {
+      const p = promises.find((x) => x.id === pid); if (!p || p.state !== "SEEDED") continue;
+      p.state = how === "overcrowd" ? "PAID" : rng.next() < 0.5 ? "EXPIRED" : "TRANSFERRED"; p.closedTick = tick;
+      deltas.push({ tick, from: "PLOT", to: "SERIES", kind: `promise-${p.state.toLowerCase()}`, detail: pid, cellId: cell.cellId });
+    }
+    cell.activePromises = []; cell.boundElementId = null;
+  };
+  const snapshot = (t: number, b: GridTick["births"], d: GridTick["deaths"]): GridTick => {
+    const active: CellState[] = cells.filter((c) => c.state === "ACTIVE").map((c) => ({ rowId: c.owner, elementId: c.boundElementId }));
+    const turnover = b.length + d.length;
+    const intensity = Math.max(0, Math.min(100, Math.round(((active.length + 2 * turnover) / (3 * rows.length)) * 100)));
+    return { t, active, births: b, deaths: d, activeCount: active.length, population: rows.length, intensity };
+  };
+
+  // ── §4.3-style seed: kernel conflict + agents + institution + setting + theme, ~30 % density
+  const ctxBase = (slot: SlotClassId): SelectionContext => ({
+    seed: genome, vacantSlot: slot, genreFamily: contract.family, audience,
+    liveSlots: new Set(cells.filter((c) => c.state === "ACTIVE" && c.boundElementId).map((c) => manifest.byId.get(c.boundElementId!)?.primarySlot ?? "SC-B")),
+    activeStakes: stakesOrder[0] ?? null, readerLoadBudget: 1, activeIds, activeBands: recentBands, bandUsage,
+    noveltyNeed: 0.6, loopLoad: 0, castLoad: 0,
+  });
+  const target = Math.max(5, Math.round(rows.length * 0.3));
+  const seedPlan: [EntityKind, SlotClassId][] = [["strand", "SC-T"], ["institution", "SC-I"], ["setting", "SC-S"], ["agent", "SC-A"], ["agent", "SC-A"], ["agent", "SC-M"], ["setting", "SC-S"], ["strand", "SC-T"]];
+  let placed = 0;
+  const shuffled = cells.map((c) => ({ c, k: rng.next() })).sort((a, b) => a.k - b.k).map((x) => x.c);
+  for (const [kind, slot] of seedPlan) {
+    const cell = shuffled.find((c) => c.kind === kind && c.state === "DORMANT"); if (!cell) continue;
+    const sel = selectCompiledElement(ctxBase(slot)); if (!sel.chosen) continue;
+    if (sel.chosen.harnessRequired && lawLive >= 1) { masked.push({ tick: 0, cellId: cell.cellId, elementId: sel.chosen.id, rule: "≤1 foreground LAW" }); continue; }
+    bind(cell, sel.chosen, 0, sel.scored[0]?.score ?? 0, "seed"); placed++;
+    if (placed >= target) break;
+  }
+  while (placed < target) {
+    const cell = shuffled.find((c) => c.state === "DORMANT"); if (!cell) break;
+    const sel = selectCompiledElement(ctxBase(SLOT_FOR_KIND[cell.kind][0])); if (!sel.chosen) break;
+    if (sel.chosen.harnessRequired && lawLive >= 1) { masked.push({ tick: 0, cellId: cell.cellId, elementId: sel.chosen.id, rule: "≤1 foreground LAW" }); cell.state = "RETIRED"; continue; }
+    bind(cell, sel.chosen, 0, sel.scored[0]?.score ?? 0, "seed-scatter"); placed++;
+  }
+  ticks.push(snapshot(0, [], [])); hashes.push(stateHash(ticks[0].active));
+  checkpoints.push({ tick: 0, hash: sha256Hex(hashes[0]).slice(0, 16), population: ticks[0].activeCount, promisesOpen: promises.filter((p) => p.state === "SEEDED").length });
+
+  // ── evolution
+  let stableConfirm = 0, budgetHit = false;
+  const volumeBounds: number[] = [0];
+  for (let t = 1; t <= budget; t++) {
+    const prev = new Map(cells.map((c) => [c.cellId, c.state === "ACTIVE"]));
+    const isLive = (cellId: string) => prev.get(cellId) === true;
+    const b: GridTick["births"] = [], d: GridTick["deaths"] = [];
+    const openLoops = promises.filter((p) => p.state === "SEEDED").length;
+    const loopLoad = Math.min(1, openLoops / 8);
+    const castNow = cells.filter((c) => c.state === "ACTIVE" && c.kind === "agent").length;
+    const castLoad = Math.min(1, castNow / 15);
+    castLoadMax = Math.max(castLoadMax, castNow); loopDebtMax = Math.max(loopDebtMax, openLoops);
+    const liveSlots = new Set(cells.filter((c) => c.state === "ACTIVE" && c.boundElementId).map((c) => manifest.byId.get(c.boundElementId!)?.primarySlot ?? "SC-B"));
+    const activeStakes = stakesOrder[(t - 1) % Math.max(1, stakesOrder.length)] ?? null;
+
+    for (const cell of cells) {
+      const A = cell.neighbors.filter(isLive).length;
+      if (cell.state === "ACTIVE") {
+        if (A < Math.min(...S)) { d.push({ rowId: cell.owner, elementId: cell.boundElementId ?? "", kind: "isolation", reason: `A=${A}` }); retire(cell, t, "isolation"); }
+        else if (A > Math.max(...S)) { d.push({ rowId: cell.owner, elementId: cell.boundElementId ?? "", kind: "overcrowd", reason: `A=${A}` }); retire(cell, t, "overcrowd"); }
+        else cell.lastTick = t;
+        continue;
+      }
+      if (!B.includes(A)) continue;
+      // §6.4 selection with §11.4 ranking terms
+      const slots = SLOT_FOR_KIND[cell.kind].filter((s) => SLOT_PRECONDITIONS[s].length === 0 || SLOT_PRECONDITIONS[s].some((p) => liveSlots.has(p)));
+      if (!slots.length) continue;
+      const slot = slots[Math.floor(rng.at(t * 7919 + fnv1a(cell.cellId)) * slots.length)];
+      const sel = selectCompiledElement({
+        seed: genome, vacantSlot: slot, genreFamily: contract.family, audience, liveSlots, activeStakes,
+        readerLoadBudget: Math.max(0, 1 - (b.length * 0.2)), activeIds, activeBands: recentBands, bandUsage,
+        noveltyNeed: 0.4 + 0.4 * (1 - Math.min(1, activeIds.size / 20)), loopLoad, castLoad,
+      });
+      if (!sel.chosen) continue;
+      const el = sel.chosen;
+      // ── audit masks (constraint-propagating, not post-hoc)
+      let rule: string | null = null;
+      const openSubstantial = promises.filter((p) => p.state === "SEEDED" && p.scope !== "LOCAL").length;
+      if (el.harnessRequired && lawLive >= 1) rule = "≤1 foreground LAW";
+      else if (cell.kind === "agent" && castNow + 1 > 15) rule = "SAGA_CAST_LOAD ≤15";
+      else if ((el.primarySlot === "SC-T" || el.primarySlot === "SC-W") && (openSubstantial >= 5 || openLoops >= 16)) rule = "loop budget (v1 §15.3: ≤5 substantial, ≤16 total)";
+      else if (b.length >= 6) rule = "reader-load: ≤6 births per tick";
+      else if (el.conflictsWith.some((c) => activeIds.has(c))) rule = "canon conflict (≠ differentiator)";
+      if (rule) { masked.push({ tick: t, cellId: cell.cellId, elementId: el.id, rule }); continue; }
+      bind(cell, el, t, sel.scored[0]?.score ?? 0, sel.reason);
+      b.push({ rowId: cell.owner, elementId: el.id, reason: `A=${A} ∈ B${JSON.stringify(B)} · ${sel.reason}` });
+    }
+    const tk = snapshot(t, b, d); ticks.push(tk);
+    const h = stateHash(tk.active); hashes.push(h);
+    checkpoints.push({ tick: t, hash: sha256Hex(hashes.join("|")).slice(0, 16), population: tk.activeCount, promisesOpen: promises.filter((p) => p.state === "SEEDED").length });
+    if (tk.activeCount === 0) break;
+    const firstSeen = hashes.slice(0, -1).indexOf(h);
+    if (firstSeen >= 0) {
+      const period = hashes.length - 1 - firstSeen;
+      stableConfirm++;
+      // quasi-stable state = volume boundary in saga/serial modes
+      if ((lengthMode === "saga" || lengthMode === "serial") && t - volumeBounds[volumeBounds.length - 1] >= 6) volumeBounds.push(t);
+      if (stableConfirm >= Math.max(1, Math.min(period, 3))) {
+        const det = detectPattern(ticks, hashes, false);
+        if (lengthMode === "flash" || targetAttractors.length === 0 || targetAttractors.includes(det.pattern) || stableConfirm >= 6) break;
+      }
+    } else stableConfirm = 0;
+    if (t === budget) budgetHit = tk.activeCount > 0;
+  }
+
+  // v3 correction of a v2 dead branch: under a hard budget the structural
+  // classifiers (RING / SPLIT / GLIDER / GLIDER-GUN / METHUSELAH) were never
+  // reachable because `budgetHit` short-circuited to BUDGET-TRUNCATED. §11.5
+  // treats a translating or mirrored pattern at budget as a legitimate
+  // attractor; only an unclassifiable live state is truncation.
+  let det = detectPattern(ticks, hashes, false);
+  if (budgetHit && ticks[ticks.length - 1].activeCount > 0) {
+    const tail = ticks.slice(-4).map((x) => x.activeCount);
+    const mean = tail.reduce((a, b2) => a + b2, 0) / Math.max(1, tail.length);
+    const settled = tail.every((x) => Math.abs(x - mean) <= Math.max(1, mean * 0.2));
+    if (det.pattern === "METHUSELAH" && !settled) det = detectPattern(ticks, hashes, true); // → BUDGET-TRUNCATED
+  }
+  const attractorInTarget = targetAttractors.includes(det.pattern);
+  const endingFamily = attractorInTarget ? contract.defaultEndingFamilies.find((e) => (ENDING_TO_ATTRACTOR[e] ?? []).includes(det.pattern)) ?? PATTERN_ENDING[det.pattern] : PATTERN_ENDING[det.pattern];
+  const compressionAdvice: string[] = [];
+  if (det.pattern === "BUDGET-TRUNCATED") compressionAdvice.push("Budget exhausted before an attractor: merge parallel strands, retire one institution, or raise the tick budget. Realization must NOT begin (§11.6).");
+  if (!attractorInTarget && det.pattern !== "BUDGET-TRUNCATED") compressionAdvice.push(`Attractor ${det.pattern} is outside the contract's target set [${targetAttractors.join(", ")}] — accept as a declared deviation or re-seed.`);
+  const openAtEnd = promises.filter((p) => p.state === "SEEDED");
+  for (const p of openAtEnd) { p.state = "RESIDUALIZED"; p.closedTick = ticks.length - 1; }
+
+  // ── compile scenes/chapters/volumes
+  if (volumeBounds[volumeBounds.length - 1] !== ticks.length - 1) volumeBounds.push(ticks.length - 1);
+  const volumeOf = (t: number) => Math.max(1, volumeBounds.findIndex((vb) => t <= vb) || 1);
+  const scenes: MorphRun["scenes"] = [];
+  const grammarWeights = contract.sceneGrammarWeights;
+  for (const tk of ticks) {
+    for (const a of tk.active) {
+      const cell = cellByOwner.get(a.rowId); const el = a.elementId ? manifest.byId.get(a.elementId) ?? null : null;
+      if (!cell) continue;
+      const g = (el?.sceneGrammars ?? ["ACTION"]).slice().sort((x, y) => (grammarWeights[y] ?? 0) - (grammarWeights[x] ?? 0))[0];
+      scenes.push({
+        index: scenes.length + 1, tick: tk.t, cellId: cell.cellId, owner: cell.owner, kind: cell.kind, element: el, grammar: g,
+        stakes: el?.stakesAxes[0] ?? "moral", cost: el?.costAxes[0] ?? "attention",
+        interior: g === "PROCESSING" || g === "AFTERMATH" || g === "RELATIONAL" || (el?.costAxes.includes("attention") ?? false),
+        volume: volumeOf(tk.t), chapter: tk.t + 1,
+      });
+    }
+  }
+  const chapters: MorphRun["chapters"] = ticks.map((tk) => {
+    const sc = scenes.filter((s) => s.tick === tk.t);
+    const cnt = new Map<StakesAxis, number>(); sc.forEach((s) => cnt.set(s.stakes, (cnt.get(s.stakes) ?? 0) + 1));
+    return { index: tk.t + 1, volume: volumeOf(tk.t), scenes: sc.length, intensity: tk.intensity, dominantStakes: [...cnt.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? null };
+  });
+  const volumes: MorphRun["volumes"] = [];
+  for (let i = 1; i < volumeBounds.length; i++) {
+    const start = volumeBounds[i - 1], end = volumeBounds[i];
+    const paid = promises.filter((p) => p.closedTick != null && p.closedTick > start && p.closedTick <= end && p.state === "PAID").length;
+    volumes.push({ index: i, startTick: start, endTick: end, localClosure: paid > 0 || i === volumeBounds.length - 1,
+      seriesDelta: deltas.filter((x) => x.tick > start && x.tick <= end && x.to === "SERIES").length + " series-scale deltas" });
+  }
+
+  return {
+    genome, userSeed: opts.userSeed >>> 0, lengthMode, budgetTicks: budget, cells, ticks, stateHashes: hashes, checkpoints,
+    deltas, promises, attractor: det.pattern, attractorDetail: det.detail, attractorInTarget, endingFamily, targetAttractors,
+    volumes, births, masked, compressionAdvice, scenes, chapters,
+    stats: {
+      births: births.length, deaths, distinctElements: new Set(births.map((x) => x.elementId)).size,
+      slotsExercised: new Set(births.map((x) => manifest.byId.get(x.elementId)?.primarySlot)).size,
+      castLoadMax, loopDebtMax,
+    },
+  };
+}
+
+export const SLOT_CLASS_LIST = SLOT_CLASS_IDS;