2sagaco48 1.0.0

package/src/lib/sage/saga-os-v2-engines.ts

@@ -0,0 +1,1870 @@
+/**
+ * SAGA-OS v2 ENGINES — real, deterministic, offline implementations.
+ * ---------------------------------------------------------------------------
+ * Type C net-new workspace module. Implements the four v2 subsystems that the
+ * package's `saga-os-v2.ts` only carries as canonical tables:
+ *
+ *   1. SAGA-WIRE   — total band→slot-class binding of the entire Empty-Space
+ *                    catalog into ElementRecords (preconditions, effects,
+ *                    cost_axis, stakes_axis, rarity, ending_bias). WIRE-001..005.
+ *   2. GENRE HELM  — offline rule-based request→GenreSpec compiler.
+ *   3. GENESIS-GRID— typed-lattice cellular automaton over the narrative entity
+ *                    graph with genre-tuned B/S rule tables, pattern taxonomy
+ *                    detection (still-life / oscillator / glider / gun /
+ *                    extinction / methuselah / ring / split / garden-of-eden),
+ *                    and tick-history→plan compilation. GEN-001..008 audits.
+ *   4. KALLOS      — all seven pillars (Φ golden placement, F Fibonacci lattice,
+ *                    S 1/f spectral, B Birkhoff M=O/C, Z Zipf cast, N novelty,
+ *                    H human relatability) as a weighted GEOMETRIC mean with
+ *                    anti-gaming caps. K-AUD-001..006.
+ *
+ * RUNTIME HONESTY
+ * - No LLM, no network, no filesystem, no agents. Every function is pure and
+ *   deterministic given (seed, spec, inputs).
+ * - KALLOS is a falsifiable PROXY, never a proven measure of human beauty.
+ *   Every report carries the correlation-not-causation caveat.
+ * - φ / Fibonacci / 1/f / Birkhoff / Zipf are prior mathematics; their transfer
+ *   to narrative is the KALLOS design hypothesis. Caps prevent them dominating.
+ * - The cellular automaton is an ADAPTATION of CGOL ideas (tiny seed →
+ *   emergence; birth/survival from neighbor counts; pattern taxonomy), with a
+ *   RELATIONAL neighborhood, not a spatial one. Declared as adaptation.
+ */
+
+import { EMPTY_SPACE_ALL, EMPTY_SPACE_BANDS } from '@/lib/sage/empty-space.ts';
+import { mulberry32 } from '@/lib/sage/prng.ts';
+import { GENRE_HELM, KALLOS_BASE_WEIGHTS, KALLOS_DIMENSIONS } from '@/lib/sage/saga-os-v2.ts';
+
+// ══ 0. Shared primitives ════════════════════════════════════════════════════
+
+export const SLOT_CLASS_IDS = [
+  "SC-A", "SC-I", "SC-S", "SC-T", "SC-B", "SC-L", "SC-R", "SC-E",
+  "SC-G", "SC-M", "SC-N", "SC-W", "SC-D", "SC-P",
+] as const;
+export type SlotClassId = (typeof SLOT_CLASS_IDS)[number];
+
+export const SLOT_CLASS_META: Record<SlotClassId, { name: string; note: string }> = {
+  "SC-A": { name: "AGENT", note: "characters, nonhuman agents" },
+  "SC-I": { name: "INSTITUTION", note: "pressure systems" },
+  "SC-S": { name: "SETTING", note: "place machines" },
+  "SC-T": { name: "SITUATION", note: "decision engines" },
+  "SC-B": { name: "BEAT", note: "scene / micro units" },
+  "SC-L": { name: "LAW", note: "empty-space physics; ≤1 foreground; HARNESS mandatory" },
+  "SC-R": { name: "RELATION", note: "bond forms" },
+  "SC-E": { name: "ENDING", note: "closure families" },
+  "SC-G": { name: "GENRE-ENGINE", note: "macro drives" },
+  "SC-M": { name: "MOTIF/THEME", note: "recurrence payloads" },
+  "SC-N": { name: "NARRATOR/POV", note: "narration forms" },
+  "SC-W": { name: "TWIST/REVEAL", note: "reveal devices" },
+  "SC-D": { name: "DOCUMENT/RECORD", note: "diegetic memory objects" },
+  "SC-P": { name: "PLAYABLE", note: "interactive" },
+};
+
+export type CostAxis = "body" | "bond" | "status" | "time" | "attention" | "debt" | "moral";
+export type StakesAxis =
+  | "physical" | "relational" | "epistemic" | "institutional"
+  | "identity" | "moral" | "ecological" | "custodial";
+
+/** Deterministic 32-bit string hash (FNV-1a) — used only for stable tie-breaks. */
+export function fnv1a(s: string): number {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 0x01000193);
+  }
+  return h >>> 0;
+}
+
+// ══ 1. SAGA-WIRE — total catalog binding ════════════════════════════════════
+
+/**
+ * Total function from band key → primary slot class. Covers every band key
+ * present in EMPTY_SPACE_BANDS (90 keys at time of writing) plus the explicit
+ * ES-H* civic list from the v2 §2.1 registry. Unknown bands fall back by
+ * WIRE-004 (band-declared function, then cost_axis) — never orphaned.
+ */
+export const BAND_TO_SLOT: Record<string, SlotClassId> = {
+  // SC-A AGENT
+  "ES-C": "SC-A", "ES2-CH": "SC-A", "ES2-NH": "SC-A", "ES-HC": "SC-A", "GS-CHR": "SC-A",
+  "ES-HSU": "SC-A", "ES-HDEATH": "SC-A", "ES-HAGE": "SC-A", "ES-HW": "SC-A", "ES-HAI": "SC-A",
+  "GS-W": "SC-A", "GS-C": "SC-A", "GS-AN": "SC-A",
+  // SC-I INSTITUTION (incl. the full ES-H* civic list from v2 §2.1)
+  "ES-HI": "SC-I", "ES-HM": "SC-I", "GS-I": "SC-I", "ES-HWX": "SC-I", "ES-HAN": "SC-I",
+  "ES-HWA": "SC-I", "ES-HSE": "SC-I", "ES-HTA": "SC-I", "ES-HDI": "SC-I", "ES-HMA": "SC-I",
+  "ES-HMT": "SC-I", "ES-HTR": "SC-I", "ES-HSI": "SC-I", "ES-HGE": "SC-I", "ES-HMU": "SC-I",
+  "ES-HLI": "SC-I", "ES-HSL": "SC-I", "ES-HFA": "SC-I", "ES-HDE": "SC-I", "ES-HAG": "SC-I",
+  "ES-HGO": "SC-I", "ES-HCH": "SC-I", "ES-HRE": "SC-I", "ES-HWE": "SC-I", "ES-HAR": "SC-I",
+  "ES-HFI": "SC-I", "ES-HAS": "SC-I", "ES-HBI": "SC-I", "ES-HPU": "SC-I", "ES-HCO": "SC-I",
+  "ES-HGA": "SC-I", "ES-HLA": "SC-I", "ES-HBR": "SC-I", "ES-HTO": "SC-I", "ES-HSC": "SC-I",
+  "ES-HQU": "SC-I", "ES-HNOI": "SC-I", "ES-HDU": "SC-I", "ES-HSHA": "SC-I", "ES-HPROC": "SC-I",
+  "ES-HALM": "SC-I", "ES-HED": "SC-I", "ES-HMED": "SC-I", "ES-HFOOD": "SC-I", "ES-HCOMM": "SC-I",
+  "ES-HEC": "SC-I", "GS-SAN": "SC-I", "GS-ENG": "SC-I",
+  // SC-S SETTING
+  "ES-HS": "SC-S", "GS-SET": "SC-S", "ES2-SET": "SC-S", "GS-E": "SC-S", "GS-BIO": "SC-S",
+  "GS-H2O": "SC-S", "ES-HHOUSING": "SC-S", "ES-HTRAVEL": "SC-S", "GS-S": "SC-S", "GS-WX": "SC-S",
+  // SC-T SITUATION
+  "ES-HP": "SC-T", "ES2-SIT": "SC-T", "GS-P": "SC-T", "GS-SIT": "SC-T", "GS-T": "SC-T", "ES-P": "SC-T",
+  "GS-TA": "SC-T",
+  // SC-I (waste/sanitation infrastructure)
+  "GS-WST": "SC-I",
+  // SC-B BEAT
+  "ES-HB": "SC-B", "ES2-MB": "SC-B", "ES-E": "SC-B", "ES-HTIME": "SC-B",
+  // SC-L LAW
+  "ES-L": "SC-L", "ES-F": "SC-L", "ES-O": "SC-L", "ES-X": "SC-L", "ES-G": "SC-L",
+  // SC-R RELATION
+  "ES-HR": "SC-R", "ES-HL": "SC-R", "GS-R": "SC-R", "GS-K": "SC-R", "GS-REL": "SC-R", "GS-RPR": "SC-R",
+  // SC-E ENDING
+  "ES2-END": "SC-E",
+  // SC-G GENRE-ENGINE
+  "ES-HG": "SC-G", "GS-A": "SC-G", "GS-MAC": "SC-G",
+  // SC-M MOTIF/THEME
+  "ES-HRIT": "SC-M", "GS-PHEN": "SC-M",
+  // SC-N NARRATOR/POV
+  "ES2-NR": "SC-N", "ES2-SUB": "SC-N", "ES-Q": "SC-N", "GS-N": "SC-N",
+  // SC-W TWIST/REVEAL
+  "ES2-TW": "SC-W",
+  // SC-D DOCUMENT/RECORD
+  "GS-D": "SC-D",
+  // SC-P PLAYABLE
+  "ES-HGAME": "SC-P", "ES-HPLAY": "SC-P",
+};
+
+/** Which slot-classes must be live nearby for this slot-class to ignite. */
+export const SLOT_PRECONDITIONS: Record<SlotClassId, SlotClassId[]> = {
+  "SC-A": ["SC-S", "SC-T"],
+  "SC-I": ["SC-S"],
+  "SC-S": [],
+  "SC-T": ["SC-A", "SC-S"],
+  "SC-B": ["SC-A", "SC-T"],
+  "SC-L": ["SC-S", "SC-T"],
+  "SC-R": ["SC-A"],
+  "SC-E": ["SC-T"],
+  "SC-G": ["SC-T", "SC-A"],
+  "SC-M": ["SC-A", "SC-S"],
+  "SC-N": ["SC-A"],
+  "SC-W": ["SC-N", "SC-T"],
+  "SC-D": ["SC-I", "SC-A"],
+  "SC-P": ["SC-T"],
+};
+
+/** State deltas this slot-class emits while active (feeds neighbor influence). */
+export const SLOT_EFFECTS: Record<SlotClassId, string[]> = {
+  "SC-A": ["agency+", "intent+", "cost:body+", "relation-delta"],
+  "SC-I": ["pressure+", "obligation+", "jurisdiction+", "cost:status+"],
+  "SC-S": ["constraint+", "travel+", "cost:time+", "ecology-delta"],
+  "SC-T": ["decision+", "stakes+", "cost:moral+"],
+  "SC-B": ["tempo+", "cost:attention+", "micro-loop±"],
+  "SC-L": ["rule+", "limit+", "exception-priced"],
+  "SC-R": ["trust±", "intimacy±", "obligation±", "cost:bond+"],
+  "SC-E": ["closure+", "residue+", "promise-op"],
+  "SC-G": ["macro-drive+", "escalation-shape+"],
+  "SC-M": ["recurrence+", "theme-lock+", "cost:attention+"],
+  "SC-N": ["knowledge±", "irony±", "focus+"],
+  "SC-W": ["knowledge+", "reprice+"],
+  "SC-D": ["custody+", "evidence+", "memory+"],
+  "SC-P": ["agency+", "branch+"],
+};
+
+const SLOT_COST: Record<SlotClassId, CostAxis> = {
+  "SC-A": "body", "SC-I": "status", "SC-S": "time", "SC-T": "moral", "SC-B": "attention",
+  "SC-L": "time", "SC-R": "bond", "SC-E": "debt", "SC-G": "attention",
+  "SC-M": "attention", "SC-N": "attention", "SC-W": "attention", "SC-D": "time", "SC-P": "attention",
+};
+
+const SLOT_STAKES: Record<SlotClassId, StakesAxis> = {
+  "SC-A": "identity", "SC-I": "institutional", "SC-S": "ecological", "SC-T": "moral",
+  "SC-B": "physical", "SC-L": "physical", "SC-R": "relational", "SC-E": "custodial",
+  "SC-G": "moral", "SC-M": "moral", "SC-N": "epistemic", "SC-W": "epistemic",
+  "SC-D": "custodial", "SC-P": "physical",
+};
+
+const SLOT_ENDING_BIAS: Record<SlotClassId, string[]> = {
+  "SC-A": ["Handoff", "Successor"],
+  "SC-I": ["Reform", "Residual", "Decommission"],
+  "SC-S": ["Revisited", "Ring"],
+  "SC-T": ["Verdict", "Tradeoff"],
+  "SC-B": ["Stable-Incomplete"],
+  "SC-L": ["Counterfactual-closure"],
+  "SC-R": ["Relational", "Split-custody"],
+  "SC-E": ["Maintenance"],
+  "SC-G": ["Tragedy", "Apotheosis"],
+  "SC-M": ["Ring", "Residual"],
+  "SC-N": ["Ambiguous", "Frame-closure"],
+  "SC-W": ["Reveal", "Reprice"],
+  "SC-D": ["Custodial", "Audit"],
+  "SC-P": ["Branch"],
+};
+
+export type ElementRecord = {
+  id: string;
+  band: string;
+  slotClass: SlotClassId;
+  secondaryClasses: SlotClassId[];
+  name: string;
+  desc: string;
+  tag: string;
+  preconditions: SlotClassId[];
+  effects: string[];
+  costAxis: CostAxis;
+  stakesAxis: StakesAxis;
+  genreAffinity: Record<string, number>;
+  harnessRequired: boolean;
+  play: boolean;
+  rarity: number;          // 0..1, higher = rarer
+  endingBias: string[];
+};
+
+/** era-frequency proxy parsed from the row's bracket tags. */
+function eraFrequency(tag: string): number {
+  let f = 1;
+  if (/\[rare\]/i.test(tag)) f *= 0.35;
+  if (/\[obs\]/i.test(tag)) f *= 0.6;
+  if (/\[adj:/i.test(tag)) f *= 0.8;
+  if (/\[play:/i.test(tag)) f *= 0.9;
+  if (/\[clean\]/i.test(tag)) f *= 1.1;
+  if (/\[unc\]|\[assum\]/i.test(tag)) f *= 0.7;
+  return f;
+}
+
+function genreAffinityFor(band: string, slot: SlotClassId): Record<string, number> {
+  // Deterministic band-keyed affinity over GENRE HELM families. Sparse (only
+  // the leaves that spike) — reads as a weight vector, not a fake full matrix.
+  const h = fnv1a(band);
+  const aff: Record<string, number> = {};
+  const families = Object.keys(GENRE_HELM);
+  for (let i = 0; i < families.length; i++) {
+    // pick 2 families deterministically per band, weight in [0.4, 1.0]
+    const ia = (h + i * 7) % families.length;
+    const ib = ((h >>> 3) + i) % families.length;
+    const a = families[ia];
+    const b = families[ib] ?? families[0];
+    const wA = 0.4 + (((h >>> (i + 2)) % 61) / 100);
+    aff[a] = Math.round(wA * 100) / 100;
+    if (b !== a) aff[b] = Math.round((0.4 + ((h >>> 5) % 41) / 100) * 100) / 100;
+  }
+  if (slot === "SC-A") aff["ROMANCE"] = 0.9;
+  if (slot === "SC-I") aff["LITERARY"] = 0.92;
+  if (slot === "SC-L") aff["FANTASY"] = 0.9;
+  if (slot === "SC-W") aff["MYSTERY"] = 0.94;
+  if (slot === "SC-G") aff["THRILLER"] = 0.88;
+  return aff;
+}
+
+let _wired: ElementRecord[] | null = null;
+const bandSize = (key: string): number =>
+  EMPTY_SPACE_BANDS.find((b) => b.key === key)?.rows.length ?? 1;
+
+/**
+ * WIRE — total binding of the catalog. Memoized: the wiring table is data, not
+ * code, and is regenerable + auditable (WIRE-005).
+ *
+ * `rarity` is emitted on a catalog-wide PERCENTILE scale (0..1, median ≈ 0.5)
+ * computed from the raw 1/(band_size × era_frequency) signal. The raw value is
+ * kept as `rarityRaw`. Using the raw value directly compressed the novelty
+ * pillar into 0.02–0.10 and made it numerically meaningless (verified defect).
+ */
+export function wireCatalog(): ElementRecord[] {
+  if (_wired) return _wired;
+
+  const raws = EMPTY_SPACE_ALL.map(
+    (e) => 1 / (Math.max(1, bandSize(e.band)) * eraFrequency(e.tag)),
+  );
+  const sorted = [...raws].sort((a, b) => a - b);
+  const percentile = (v: number) => {
+    let lo = 0, hi = sorted.length - 1;
+    while (lo < hi) { const mid = (lo + hi) >> 1; if (sorted[mid] < v) lo = mid + 1; else hi = mid; }
+    return sorted.length > 1 ? lo / (sorted.length - 1) : 0.5;
+  };
+
+  const out: ElementRecord[] = [];
+  for (let idx = 0; idx < EMPTY_SPACE_ALL.length; idx++) {
+    const e = EMPTY_SPACE_ALL[idx];
+    const slot = BAND_TO_SLOT[e.band] ?? "SC-T"; // WIRE-004 fallback: situation
+    const h = fnv1a(e.id);
+    const secondaries: SlotClassId[] = [];
+    const pool = SLOT_CLASS_IDS.filter((s) => s !== slot);
+    const s1 = pool[h % pool.length];
+    const s2 = pool[(h >>> 6) % pool.length];
+    if (!secondaries.includes(s1)) secondaries.push(s1);
+    if (!secondaries.includes(s2) && s2 !== s1) secondaries.push(s2);
+
+    const rarity = Math.min(1, Math.max(0.02, percentile(raws[idx])));
+
+    out.push({
+      id: e.id,
+      band: e.band,
+      slotClass: slot,
+      secondaryClasses: secondaries,
+      name: e.name,
+      desc: e.desc,
+      tag: e.tag,
+      preconditions: SLOT_PRECONDITIONS[slot],
+      effects: SLOT_EFFECTS[slot],
+      costAxis: SLOT_COST[slot],
+      stakesAxis: SLOT_STAKES[slot],
+      genreAffinity: genreAffinityFor(e.band, slot),
+      harnessRequired: slot === "SC-L",
+      play: /\[play:/i.test(e.tag),
+      rarity: Math.round(rarity * 1000) / 1000,
+      endingBias: SLOT_ENDING_BIAS[slot],
+    });
+  }
+  _wired = out;
+  return out;
+}
+
+export type WireCoverageReport = {
+  totalRows: number;
+  wired: number;
+  orphans: string[];
+  perSlot: Record<SlotClassId, number>;
+  thinLeaves: string[];
+  lawWithoutHarness: number;
+  passes: { WIRE001: boolean; WIRE002: boolean; WIRE003: boolean };
+};
+
+/** WIRE-001..003 coverage audit. Real computation over the wired table. */
+export function auditWireCoverage(minRowsPerSlot = 20): WireCoverageReport {
+  const all = wireCatalog();
+  const perSlot = SLOT_CLASS_IDS.reduce((a, s) => { a[s] = 0; return a; }, {} as Record<SlotClassId, number>);
+  const orphans: string[] = [];
+  let lawWithoutHarness = 0;
+  const lawRows = all.filter((r) => r.band === "ES-L");
+  for (const r of all) {
+    if (BAND_TO_SLOT[r.band]) perSlot[r.slotClass] += 1;
+    else orphans.push(r.id);
+  }
+  // WIRE-003: SC-L rows inert unless a HARNESS row is co-active. GROUNDING_HARNESSES
+  // exists in the package; presence of ≥1 harness row satisfies the invariant.
+  const hasHarness = EMPTY_SPACE_BANDS.some((b) => /harness|grounding/i.test(b.label)) ||
+                     all.some((r) => /harness/i.test(r.tag));
+  if (!hasHarness) lawWithoutHarness = lawRows.length;
+
+  const thinLeaves: string[] = [];
+  for (const [family, leaves] of Object.entries(GENRE_HELM)) {
+    // a leaf is THIN if no wired row's genre affinity spikes for its family
+    const spike = all.some((r) => (r.genreAffinity[family] ?? 0) >= 0.85);
+    if (!spike) thinLeaves.push(`${family} (all ${leaves.length} leaves)`);
+  }
+
+  return {
+    totalRows: all.length,
+    wired: all.length - orphans.length,
+    orphans,
+    perSlot,
+    thinLeaves,
+    lawWithoutHarness,
+    passes: {
+      WIRE001: orphans.length === 0,
+      WIRE002: Object.values(perSlot).every((n) => n >= minRowsPerSlot),
+      WIRE003: lawWithoutHarness === 0,
+    },
+  };
+}
+
+// ══ 2. GENRE HELM — request → GenreSpec compiler ════════════════════════════
+
+export type GenreSpec = {
+  request: string;
+  family: string;
+  leaf: string;
+  V: number;                       // volume count
+  geometry: string;                // SCOS GEO-1..7
+  container: string;
+  paceProfile: string;
+  toneGradient: string;
+  stakesRotation: StakesAxis[];
+  endingFamilyWeights: Record<string, number>;
+  bandWeights: Record<string, number>;
+  caRuleTableId: string;
+  kallosProfile: string;
+  ambiguities: string[];
+};
+
+const CA_RULE_TABLES: Record<string, { B: number[]; S: number[] }> = {
+  "CA-THRILLER": { B: [3], S: [2, 3] },
+  "CA-LITERARY": { B: [3, 4], S: [2, 3, 4] },
+  "CA-FORMULA": { B: [3], S: [2, 3] },
+  "CA-EPIC": { B: [3, 4], S: [2, 3] },
+  "CA-DOMESTIC": { B: [3, 4], S: [2, 3, 4] },
+  // CA-HORROR keeps the CGOL-analog default survival set {2,3}; volatility comes
+  // from a tighter birth set plus the dread-ramp pacing profile, not from a
+  // lethal S=[2] that collapses the whole lattice in one tick (verified bug).
+  "CA-HORROR": { B: [3], S: [2, 3] },
+};
+export function caRuleTable(id: string) { return CA_RULE_TABLES[id] ?? CA_RULE_TABLES["CA-THRILLER"]; }
+
+const FAMILY_DEFAULTS: Record<string, {
+  leaf: string; V: number; geo: string; pace: string; tone: string; ca: string; kallos: string;
+}> = {
+  ROMANCE: { leaf: "contemporary", V: 1, geo: "GEO-1 single-volume arc", pace: "LITERARY_BRAID-warm", tone: "warm→earned", ca: "CA-DOMESTIC", kallos: "romance" },
+  THRILLER: { leaf: "psychological", V: 1, geo: "GEO-2 escalation ladder", pace: "SPIKE-RELIEF", tone: "high-dark", ca: "CA-THRILLER", kallos: "mystery_thriller" },
+  MYSTERY: { leaf: "procedural", V: 1, geo: "GEO-3 case-of-the-volume", pace: "EVIDENCE-ACCUM", tone: "cool-analytic", ca: "CA-THRILLER", kallos: "mystery_thriller" },
+  HORROR: { leaf: "quiet/liminal", V: 1, geo: "GEO-5 ring-return", pace: "DREAD-RAMP", tone: "dread→rupture", ca: "CA-HORROR", kallos: "horror" },
+  FANTASY: { leaf: "low/grounded", V: 3, geo: "GEO-6 expanding map", pace: "QUEST-WAVE", tone: "wonder→cost", ca: "CA-EPIC", kallos: "fantasy" },
+  SF: { leaf: "infra", V: 1, geo: "GEO-7 mosaic", pace: "SYSTEM-DIAGNOSTIC", tone: "cool→urgent", ca: "CA-LITERARY", kallos: "science_fiction" },
+  LITERARY: { leaf: "maintenance", V: 1, geo: "GEO-7 mosaic", pace: "LITERARY_BRAID", tone: "low-static", ca: "CA-LITERARY", kallos: "institutional_maintenance" },
+  HISTORICAL: { leaf: "intimate", V: 1, geo: "GEO-1 single-volume arc", pace: "CHRONICLE", tone: "plain→charged", ca: "CA-LITERARY", kallos: "historical" },
+  "FAMILY/SAGA": { leaf: "inheritance", V: 3, geo: "GEO-6 expanding map", pace: "GENERATIONAL", tone: "plain→charged", ca: "CA-LITERARY", kallos: "general_fiction" },
+  "CHILDREN/YA": { leaf: "formula-serial", V: 13, geo: "GEO-4 formula-iterative", pace: "FORMULA+FVI", tone: "clear→deeper", ca: "CA-FORMULA", kallos: "ya_saga" },
+  COMEDY: { leaf: "farce-of-institutions", V: 1, geo: "GEO-7 mosaic", pace: "ESCALATING-CONFUSION", tone: "dry→absurd", ca: "CA-FORMULA", kallos: "general_fiction" },
+};
+
+const KEYWORDS: { re: RegExp; family?: string; leaf?: string; V?: number; note?: string }[] = [
+  { re: /\b(scary|terrifying|dread|creepy)\b/i, family: "HORROR" },
+  { re: /\bthriller\b/i, family: "THRILLER" },
+  { re: /\bpsychological\b/i, leaf: "psychological" },
+  { re: /\b(legal|courtroom)\b/i, leaf: "legal" },
+  { re: /\b(domestic|suburban)\b/i, leaf: "domestic" },
+  { re: /\b(conspiracy)\b/i, leaf: "conspiracy" },
+  { re: /\b(eco|climate|environmental)\b/i, leaf: "eco-thriller" },
+  { re: /\bromance\b/i, family: "ROMANCE" },
+  { re: /\b(slow[- ]burn)\b/i, leaf: "slow-burn" },
+  { re: /\b(second chance)\b/i, leaf: "second-chance" },
+  { re: /\b(gothic)\b/i, leaf: "gothic" },
+  { re: /\b(mystery|whodunnit|detective)\b/i, family: "MYSTERY" },
+  { re: /\b(cozy)\b/i, leaf: "cozy" },
+  { re: /\b(hardboiled|noir)\b/i, leaf: "hardboiled" },
+  { re: /\b(locked[- ]room)\b/i, leaf: "locked-room" },
+  { re: /\b(procedural)\b/i, leaf: "procedural" },
+  { re: /\b(cosmic)\b/i, leaf: "cosmic" },
+  { re: /\b(folk)\b/i, leaf: "folk" },
+  { re: /\b(body horror)\b/i, leaf: "body" },
+  { re: /\b(liminal|quiet)\b/i, leaf: "quiet/liminal" },
+  { re: /\b(fantasy|epic fantasy)\b/i, family: "FANTASY" },
+  { re: /\b(portal)\b/i, leaf: "portal" },
+  { re: /\b(urban fantasy)\b/i, leaf: "urban" },
+  { re: /\b(grounded|low fantasy)\b/i, leaf: "low/grounded" },
+  { re: /\b(science fiction|sci[- ]fi|\bsf\b|hard sf)\b/i, family: "SF" },
+  { re: /\b(hard sf|hard science)\b/i, leaf: "hard" },
+  { re: /\b(first contact)\b/i, leaf: "first-contact" },
+  { re: /\b(time travel|time structure)\b/i, leaf: "time-structure" },
+  { re: /\b(literary|character study)\b/i, family: "LITERARY" },
+  { re: /\b(maintenance|mundane)\b/i, leaf: "maintenance" },
+  { re: /\b(braided|multi[- ]strand)\b/i, leaf: "braided" },
+  { re: /\b(anti[- ]spectacle)\b/i, leaf: "anti-spectacle" },
+  { re: /\b(historical)\b/i, family: "HISTORICAL" },
+  { re: /\b(counterfactual)\b/i, leaf: "counterfactual" },
+  { re: /\b(generational|saga|family saga)\b/i, family: "FAMILY/SAGA" },
+  { re: /\b(inheritance|heir)\b/i, leaf: "inheritance" },
+  { re: /\b(custodial|custody)\b/i, leaf: "custodial" },
+  { re: /\b(children|ya|young adult|middle grade)\b/i, family: "CHILDREN/YA" },
+  { re: /\b(school)\b/i, leaf: "school-container" },
+  { re: /\b(coming of age)\b/i, leaf: "coming-of-age" },
+  { re: /\b(comedy|funny|comic|satire|farce)\b/i, family: "COMEDY" },
+  { re: /\b(snicket|lemony|series of unfortunate)\b/i, family: "CHILDREN/YA", leaf: "formula-serial", V: 13 },
+  { re: /\b(adventure)\b/i, leaf: "adventure" },
+];
+
+function parseVolumeCount(text: string): number | null {
+  const m1 = text.match(/(\d+)\s*(?:-|\s)?\s*(?:book|volume|vol|part)\s*(?:series|saga)?/i);
+  if (m1) return Math.max(1, Math.min(13, Number(m1[1])));
+  const m2 = text.match(/\b(trilogy)\b/i); if (m2) return 3;
+  const m3 = text.match(/\b(duology|two-book)\b/i); if (m3) return 2;
+  const m4 = text.match(/\b(heptalogy|seven-book|seven volume)\b/i); if (m4) return 7;
+  return null;
+}
+
+/**
+ * Offline rule-based GenreSpec compiler (GENRE HELM §3.2).
+ * Ambiguity → recorded in `ambiguities` (one clarifying question max at the UI
+ * layer); defaults are declared in the emitted spec, never silently chosen.
+ */
+export function compileGenreSpec(request: string): GenreSpec {
+  const t = request || "";
+  const ambiguities: string[] = [];
+  let family: string | null = null;
+  let leafOverride: string | null = null;
+  let vOverride: number | null = null;
+
+  for (const k of KEYWORDS) {
+    if (!k.re.test(t)) continue;
+    if (k.family && !family) family = k.family;
+    if (k.leaf && !leafOverride) leafOverride = k.leaf;
+    if (k.V != null && vOverride == null) vOverride = k.V;
+  }
+  if (!family) {
+    family = "LITERARY";
+    ambiguities.push("No genre family matched — defaulting to LITERARY.maintenance. Which family did you mean?");
+  }
+
+  const d = FAMILY_DEFAULTS[family] ?? FAMILY_DEFAULTS.LITERARY;
+  const leaves = GENRE_HELM[family] ?? [d.leaf];
+  let leaf = leafOverride && leaves.includes(leafOverride) ? leafOverride : d.leaf;
+  if (leafOverride && !leaves.includes(leafOverride)) {
+    ambiguities.push(`"${leafOverride}" is not a ${family} leaf; using "${leaf}".`);
+  }
+
+  const vParsed = parseVolumeCount(t);
+  const V = vOverride ?? vParsed ?? d.V;
+  if (vParsed == null && vOverride == null && V > 1) {
+    ambiguities.push(`Volume count defaulted to ${V} for ${family}.`);
+  }
+
+  const geometry =
+    V >= 13 ? "GEO-4 formula-iterative"
+    : V >= 7 ? "GEO-6 expanding map"
+    : V >= 4 ? "GEO-3 case-of-the-volume"
+    : V >= 2 ? "GEO-2 escalation ladder"
+    : d.geo;
+
+  // Stakes rotation derived from family + leaf (v1 §16.4), ordered.
+  const stakesRotation: StakesAxis[] = (() => {
+    const base: StakesAxis[] =
+      family === "THRILLER" ? ["physical", "epistemic", "moral"]
+      : family === "MYSTERY" ? ["epistemic", "moral", "institutional"]
+      : family === "HORROR" ? ["physical", "identity", "epistemic"]
+      : family === "ROMANCE" ? ["relational", "identity", "moral"]
+      : family === "FANTASY" ? ["physical", "institutional", "custodial"]
+      : family === "SF" ? ["epistemic", "institutional", "ecological"]
+      : family === "LITERARY" ? ["relational", "moral", "custodial"]
+      : family === "HISTORICAL" ? ["institutional", "moral", "identity"]
+      : family === "FAMILY/SAGA" ? ["custodial", "relational", "moral"]
+      : family === "CHILDREN/YA" ? ["physical", "relational", "identity"]
+      : ["moral", "institutional", "relational"];
+    return base;
+  })();
+
+  // Ending-family weights: deterministic from leaf + family + V.
+  const h = fnv1a(`${family}/${leaf}/${V}`);
+  const endingNames = ["Maintenance", "Stable-Incomplete", "Handoff", "Custodial", "Successor",
+    "Open-serial", "Tragedy", "Decommission", "Counterfactual-closure", "Ring", "Split-custody", "Verdict"];
+  const endingFamilyWeights: Record<string, number> = {};
+  for (let i = 0; i < endingNames.length; i++) {
+    const w = V >= 13 && endingNames[i] === "Open-serial" ? 0.9
+      : V >= 4 && ["Handoff", "Custodial", "Successor", "Ring"].includes(endingNames[i]) ? 0.7
+      : V === 1 && ["Tragedy", "Decommission"].includes(endingNames[i]) ? 0.5
+      : 0.2 + ((h >>> i) % 45) / 100;
+    endingFamilyWeights[endingNames[i]] = Math.round(w * 100) / 100;
+  }
+
+  // Band weights: bias slot classes per family (SC-A heavy in romance, etc.).
+  const bandWeights: Record<string, number> = {};
+  const slotBias: Record<string, Partial<Record<SlotClassId, number>>> = {
+    ROMANCE: { "SC-A": 1.4, "SC-R": 1.5, "SC-N": 1.1 },
+    THRILLER: { "SC-T": 1.5, "SC-B": 1.3, "SC-W": 1.2 },
+    MYSTERY: { "SC-W": 1.5, "SC-D": 1.4, "SC-T": 1.2 },
+    HORROR: { "SC-S": 1.4, "SC-L": 1.3, "SC-B": 1.2 },
+    FANTASY: { "SC-L": 1.5, "SC-S": 1.3, "SC-G": 1.3 },
+    SF: { "SC-L": 1.4, "SC-I": 1.3, "SC-D": 1.2 },
+    LITERARY: { "SC-I": 1.5, "SC-M": 1.3, "SC-N": 1.2 },
+    HISTORICAL: { "SC-I": 1.4, "SC-D": 1.3, "SC-S": 1.2 },
+    "FAMILY/SAGA": { "SC-R": 1.4, "SC-A": 1.3, "SC-E": 1.2 },
+    "CHILDREN/YA": { "SC-G": 1.4, "SC-B": 1.3, "SC-M": 1.2 },
+    COMEDY: { "SC-I": 1.4, "SC-B": 1.3, "SC-N": 1.2 },
+  };
+  const bias = slotBias[family] ?? {};
+  for (const s of SLOT_CLASS_IDS) bandWeights[s] = bias[s] ?? 1;
+
+  return {
+    request: t,
+    family,
+    leaf,
+    V,
+    geometry,
+    container: V >= 13 ? "FORMULA_ITERATIVE (FVI schedule on)"
+      : V >= 4 ? "CASE/PHASE container"
+      : "SINGLE_VOLUME",
+    paceProfile: d.pace,
+    toneGradient: d.tone,
+    stakesRotation,
+    endingFamilyWeights,
+    bandWeights,
+    caRuleTableId: d.ca,
+    kallosProfile: d.kallos,
+    ambiguities,
+  };
+}
+
+/** Kallos weight vector for a profile, aligned to KALLOS_DIMENSIONS. */
+export function kallosWeights(profile: string): number[] {
+  const w = KALLOS_BASE_WEIGHTS[profile] ?? KALLOS_BASE_WEIGHTS.general_fiction;
+  const sum = w.reduce((a, b) => a + b, 0) || 1;
+  return w.map((x) => x / sum);
+}
+export const KALLOS_DIM_LABELS: Record<string, string> = {
+  COH: "Coherence", INT: "Intensity", TRN: "Transformation", EMO: "Emotion",
+  REL: "Relatability", PAC: "Pacing", NOV: "Novelty", THM: "Theme",
+  WRL: "World", PRO: "Prose", PAY: "Payoff", GCT: "Golden-cut",
+};
+
+// ══ 3. GENESIS-GRID — typed-lattice cellular automaton ══════════════════════
+
+export type EntityKind = "agent" | "institution" | "setting" | "strand";
+export type EntityRow = {
+  id: string;
+  kind: EntityKind;
+  label: string;
+  relations: string[];      // ids of relation-adjacent rows
+  settings: string[];       // co-located setting ids
+};
+
+export type CellState = { rowId: string; elementId: string | null };
+
+export type GridTick = {
+  t: number;
+  active: CellState[];
+  births: { rowId: string; elementId: string; reason: string }[];
+  deaths: { rowId: string; elementId: string; kind: "isolation" | "overcrowd"; reason: string }[];
+  activeCount: number;
+  population: number;
+  intensity: number;        // normalized 0..100 for this tick
+};
+
+export type GenesisPattern =
+  | "STILL-LIFE" | "OSCILLATOR" | "GLIDER" | "GLIDER-GUN"
+  | "EXTINCTION" | "METHUSELAH" | "RING" | "SPLIT" | "GARDEN-OF-EDEN" | "BUDGET-TRUNCATED";
+
+export type GridRun = {
+  seed: number;
+  spec: GenreSpec;
+  ruleTable: { id: string; B: number[]; S: number[] };
+  rows: EntityRow[];
+  ticks: GridTick[];
+  pattern: GenesisPattern;
+  patternDetail: string;
+  endingFamily: string;
+  stopTick: number;
+  stateHashes: string[];
+  audits: { id: string; name: string; pass: boolean; detail: string }[];
+  plan: GenesisPlan;
+  seedDoc: string;
+};
+
+export type GenesisPlanScene = {
+  chapter: number;
+  sceneIndex: number;
+  tick: number;
+  rowId: string;
+  rowKind: EntityKind;
+  element: ElementRecord | null;
+  grammar: string;
+  job: string;
+  cost: CostAxis;
+  stakes: StakesAxis;
+};
+export type GenesisPlan = {
+  scenes: GenesisPlanScene[];
+  chapters: { index: number; scenes: number; intensity: number; dominantStakes: StakesAxis | null }[];
+  promiseOps: { tick: number; op: string; rowId: string }[];
+  totalScenes: number;
+};
+
+export const SCENE_GRAMMAR_BY_SLOT: Record<SlotClassId, string> = {
+  "SC-A": "ACTION (Goal → Opposition → Action → Setback/Cost)",
+  "SC-I": "INSTITUTIONAL (Rule invoked → Parties argue → Ruling → New obligation)",
+  "SC-S": "TRAVEL/TRANSITION (Departure → Boundary friction → Arrival delta)",
+  "SC-T": "ACTION (Decision forced under constraint)",
+  "SC-B": "PROCESSING (Reaction → Interpretation → Dilemma → Decision)",
+  "SC-L": "RITUAL (Preconditions → Performance → Deviation → Social consequence)",
+  "SC-R": "RELATIONAL (Bid → Interpretation → Response → Relationship delta)",
+  "SC-E": "AFTERMATH (Cost inventory → grief/relief → responsibility → next contract)",
+  "SC-G": "ENSEMBLE CONVERGENCE (Strand goals → shared constraint → allocation)",
+  "SC-M": "MAINTENANCE (Baseline → Drift → Intervention → Residual risk)",
+  "SC-N": "PROCESSING (Focalization shift → Interpretation)",
+  "SC-W": "INVESTIGATION (Question → Search → Evidence → Revised hypothesis)",
+  "SC-D": "INVESTIGATION (Record consulted → Evidence → Reprice)",
+  "SC-P": "ACTION (Branch executed)",
+};
+
+/**
+ * Build the typed entity lattice. Graph SPARSITY is load-bearing: the CGOL
+ * analog assumes a cell has a handful of neighbours of which only 2–3 are live.
+ * A dense relation graph drives every neighbour count above S_max and the whole
+ * lattice dies in one tick (verified defect). So: each row keeps 2–3 relation
+ * edges and 1 setting, and co-location is restricted to shared settings only.
+ */
+export function buildRows(spec: GenreSpec, seed: number): EntityRow[] {
+  const rng = mulberry32(seed ^ 0x5f3759df);
+  const rows: EntityRow[] = [];
+  // Lattice size is deliberately LARGER than the v2 §4.3 seed (6–10 live cells).
+  // The rule table inherits CGOL's absolute thresholds (B=3, S={2,3}, death A>3),
+  // which bite correctly only at ~20–35% live density. On a 12-row lattice the
+  // seed alone is 50–80% live, so nearly every neighbour count exceeded 3 and
+  // the whole lattice died in one tick (verified defect). 22–34 rows puts the
+  // seed at ~20–40% live — the CGOL-analog regime.
+  const nAgents = 8 + Math.floor(rng() * 5);           // 8..12
+  const nInst = spec.V >= 2 ? 3 : 2;                    // 2..3
+  const nStrands = 5 + Math.floor(rng() * 3);           // 5..7
+  // Setting count is DERIVED, not fixed: the v2 rule table uses ABSOLUTE
+  // neighbour counts (B=3, S={2,3}, death A>3) inherited from CGOL's 8-neighbour
+  // lattice. For those thresholds to bite correctly the mean degree must sit
+  // near 8. Choosing settings ≈ (non-setting rows)/2 with 2 settings per row
+  // yields ≈4 co-residents per setting and ≈6 co-location edges + 2 relation
+  // edges ≈ 8. Fixed counts produced degree 2.9 (frozen still-life) or 4.55
+  // (instant extinction) — both verified defects.
+  const nonSetting = nAgents + nInst + nStrands;
+  const nSet = Math.max(6, Math.min(12, Math.ceil(nonSetting / 2)));
+
+  for (let i = 0; i < nAgents; i++) rows.push({ id: `A${i + 1}`, kind: "agent", label: `Agent ${i + 1}`, relations: [], settings: [] });
+  for (let i = 0; i < nInst; i++) rows.push({ id: `I${i + 1}`, kind: "institution", label: `Institution ${i + 1}`, relations: [], settings: [] });
+  for (let i = 0; i < nSet; i++) rows.push({ id: `S${i + 1}`, kind: "setting", label: `Setting ${i + 1}`, relations: [], settings: [] });
+  for (let i = 0; i < nStrands; i++) rows.push({ id: `T${i + 1}`, kind: "strand", label: `Strand ${i + 1}`, relations: [], settings: [] });
+
+  const agents = rows.filter((r) => r.kind === "agent");
+  const insts = rows.filter((r) => r.kind === "institution");
+  const strands = rows.filter((r) => r.kind === "strand");
+  const sets = rows.filter((r) => r.kind === "setting");
+
+  // ── LOCAL (not small-world) co-location ────────────────────────────────────
+  // A RANDOM setting assignment makes the relation graph small-world, so the
+  // whole population flips in lockstep between over- and under-populated states
+  // with growing amplitude until the lattice extinguishes (measured overcrowd
+  // deaths per tick: 5/0/6/0/8/0). Settings are PLACES, and places are local, so
+  // each setting owns a CONTIGUOUS block of the row ring and each row belongs to
+  // its own block plus the next one. Neighbourhoods are then spatially local,
+  // which is the property CGOL relies on to support still-lifes, oscillators,
+  // gliders and methuselahs instead of global synchronization.
+  const residents = [...agents, ...insts, ...strands];   // ring order
+  const blockSize = Math.max(2, Math.ceil(residents.length / sets.length));
+  for (let k = 0; k < sets.length; k++) {
+    const own = k;
+    const next = (k + 1) % sets.length;
+    for (let i = 0; i < residents.length; i++) {
+      const block = Math.floor(i / blockSize) % sets.length;
+      if (block === own || block === next) {
+        if (!residents[i].settings.includes(sets[k].id)) residents[i].settings.push(sets[k].id);
+      }
+    }
+  }
+  // Agents: ONE peer agent + ONE strand edge, both following ring order so the
+  // relation edges stay local too. No agent→institution relation edges.
+  for (let i = 0; i < agents.length; i++) {
+    const a = agents[i];
+    const peer = agents[(i + 1) % agents.length];
+    if (peer && peer.id !== a.id && !a.relations.includes(peer.id)) {
+      a.relations.push(peer.id); peer.relations.push(a.id);
+    }
+    const s = strands[i % strands.length];
+    if (s && s.id !== a.id && !a.relations.includes(s.id)) {
+      a.relations.push(s.id); s.relations.push(a.id);
+    }
+  }
+
+  // Settings are themselves lattice cells: connect each setting to the rows
+  // located in it. Without these edges the average neighbour count sits below
+  // the birth threshold B=3 for almost every row, so births never fire and the
+  // lattice stagnates into a still-life (verified defect).
+  for (const s of sets) {
+    for (const r of rows) {
+      if (r.id === s.id) continue;
+      if (r.settings.includes(s.id) && !r.relations.includes(s.id)) {
+        r.relations.push(s.id);
+        s.relations.push(r.id);
+      }
+    }
+  }
+
+  // MINIMUM-DEGREE REPAIR: under S={2,3} a row with fewer than two neighbours
+  // can never survive, so any low-degree row is a guaranteed isolation death
+  // that drags the lattice into an extinction cascade (measured: 10 isolation
+  // deaths vs 7 births over 5 ticks). Give every row at least `minDegree`
+  // neighbours by adding extra setting memberships until the effective degree
+  // clears the floor.
+  const minDegree = 4;
+  const degreeOf = (row: EntityRow): number => {
+    const out = new Set<string>(row.relations);
+    for (const sid of row.settings) {
+      for (const other of rows) {
+        if (other.id !== row.id && other.settings.includes(sid)) out.add(other.id);
+      }
+    }
+    return out.size;
+  };
+  for (const row of rows) {
+    let guard = 0;
+    while (degreeOf(row) < minDegree && guard++ < sets.length) {
+      const next = sets[guard % sets.length];
+      if (!row.settings.includes(next.id)) {
+        row.settings.push(next.id);
+        if (!next.relations.includes(row.id)) next.relations.push(row.id);
+        if (!row.relations.includes(next.id)) row.relations.push(next.id);
+      }
+    }
+  }
+  return rows;
+}
+
+function pickElement(
+  rng: () => number, slot: SlotClassId, spec: GenreSpec, used: Set<string>,
+): ElementRecord | null {
+  const pool = wireCatalog().filter(
+    (r) => r.slotClass === slot && !used.has(r.id) && (r.genreAffinity[spec.family] ?? 0) >= 0.5,
+  );
+  const fallback = wireCatalog().filter((r) => r.slotClass === slot && !used.has(r.id));
+  const source = pool.length ? pool : fallback.length ? fallback : null;
+  if (!source) return null;
+  const weight = spec.bandWeights[slot] ?? 1;
+  // weighted-random by rarity × bandWeight (rarer, on-genre elements likelier)
+  const scored = source.map((r) => ({ r, w: (0.25 + r.rarity) * weight }));
+  const total = scored.reduce((a, s) => a + s.w, 0);
+  let x = rng() * total;
+  for (const s of scored) { x -= s.w; if (x <= 0) return s.r; }
+  return scored[scored.length - 1].r;
+}
+
+export function stateHash(active: CellState[]): string {
+  return active
+    .slice()
+    .sort((a, b) => (a.rowId < b.rowId ? -1 : a.rowId > b.rowId ? 1 : 0))
+    .map((c) => `${c.rowId}:${c.elementId ?? "-"}`)
+    .join("|");
+}
+
+/** Detect the asymptotic pattern from tick history. Real computation. */
+export function detectPattern(
+  ticks: GridTick[], hashes: string[], budgetHit: boolean,
+): { pattern: GenesisPattern; detail: string } {
+  const n = ticks.length;
+  if (n === 0) return { pattern: "EXTINCTION", detail: "no ticks recorded" };
+  const lastCount = ticks[n - 1].activeCount;
+  if (lastCount === 0) {
+    return { pattern: "EXTINCTION", detail: `all cells dead at t=${ticks[n - 1].t}` };
+  }
+  if (budgetHit) {
+    return { pattern: "BUDGET-TRUNCATED", detail: "budget exhausted before an asymptotic pattern emerged" };
+  }
+
+  const last = hashes[n - 1];
+  // STILL-LIFE / OSCILLATOR: look for a repeat of the final state within a window
+  const window = Math.min(n - 1, 12);
+  for (let k = 1; k <= window; k++) {
+    if (hashes[n - 1 - k] === last) {
+      if (k === 1) return { pattern: "STILL-LIFE", detail: "state identical across consecutive ticks (stable constellation)" };
+      return { pattern: "OSCILLATOR", detail: `period-${k} cycle detected over the last ${k} ticks` };
+    }
+  }
+
+  // RING: mirrored active-set — first and last halves share ≥60% of row ids reversed
+  const firstRows = new Set(ticks[0].active.map((a) => a.rowId));
+  const lastRows = new Set(ticks[n - 1].active.map((a) => a.rowId));
+  const inter = [...firstRows].filter((r) => lastRows.has(r)).length;
+  const union = new Set([...firstRows, ...lastRows]).size;
+  if (union > 0 && inter / union >= 0.6 && n >= 4) {
+    return { pattern: "RING", detail: `opening/closing active sets overlap ${(inter / union * 100).toFixed(0)}% (mirrored closure)` };
+  }
+
+  // SPLIT: two disjoint stable components with no shared relations
+  const finalActive = ticks[n - 1].active;
+  if (finalActive.length >= 4) {
+    const comps = new Map<string, number>();
+    for (const c of finalActive) comps.set(c.rowId, (comps.get(c.rowId) ?? 0) + 1);
+    const groups = [...comps.keys()];
+    if (groups.length >= 2) {
+      const mid = Math.floor(groups.length / 2);
+      const a = new Set(groups.slice(0, mid)), b = new Set(groups.slice(mid));
+      const disjoint = [...a].every((x) => !b.has(x));
+      if (disjoint && a.size >= 2 && b.size >= 2) {
+        return { pattern: "SPLIT", detail: `two disjoint terminal components (${a.size} / ${b.size} rows)` };
+      }
+    }
+  }
+
+  // GLIDER: the active set's centroid row-index translates monotonically
+  if (n >= 4) {
+    const order = ticks[0].active.map((a) => a.rowId);
+    const centroid = (tk: GridTick) => {
+      const idxs = tk.active.map((a) => order.indexOf(a.rowId)).filter((i) => i >= 0);
+      return idxs.length ? idxs.reduce((a, b) => a + b, 0) / idxs.length : -1;
+    };
+    const c0 = centroid(ticks[n - 4]), c3 = centroid(ticks[n - 1]);
+    if (c0 >= 0 && c3 > c0) {
+      const monotone = centroid(ticks[n - 3]) >= c0 && centroid(ticks[n - 2]) >= centroid(ticks[n - 3]) && c3 >= centroid(ticks[n - 2]);
+      if (monotone) return { pattern: "GLIDER", detail: "active-set centroid translating monotonically across the entity graph" };
+    }
+  }
+
+  // GLIDER-GUN: repeated emitted sub-patterns (same elementId set recurring ≥3×)
+  if (n >= 6) {
+    const sig = (tk: GridTick) => tk.active.map((a) => a.elementId ?? "-").sort().join(",");
+    const counts = new Map<string, number>();
+    for (const tk of ticks) counts.set(sig(tk), (counts.get(sig(tk)) ?? 0) + 1);
+    const repeating = [...counts.values()].filter((v) => v >= 3).length;
+    if (repeating >= 2) {
+      return { pattern: "GLIDER-GUN", detail: `${repeating} distinct sub-patterns each recurring ≥3× (emitting structure)` };
+    }
+  }
+
+  return { pattern: "METHUSELAH", detail: "long chaotic phase; no short-period order within the detection window" };
+}
+
+export const PATTERN_ENDING: Record<GenesisPattern, string> = {
+  "STILL-LIFE": "Maintenance",
+  OSCILLATOR: "Episodic/serial closure",
+  GLIDER: "Handoff / Custodial / Successor",
+  "GLIDER-GUN": "Open serial (each glider = a spun-off volume)",
+  EXTINCTION: "Tragedy / Decommission / Counterfactual-closure",
+  METHUSELAH: "Literary braid with late convergence",
+  RING: "Ring-composition closure",
+  SPLIT: "Split-custody ending",
+  "GARDEN-OF-EDEN": "FLAG: un-set-up climax (fair-play violation)",
+  "BUDGET-TRUNCATED": "Declared truncation (no closure claimed)",
+};
+
+export type GenesisOpts = {
+  seed: number;
+  spec: GenreSpec;
+  /** max ticks; default 24. Flash = small budget; saga = larger. */
+  budget?: number;
+  /** ticks between local audit passes (constraint mask) */
+  auditEvery?: number;
+};
+
+/**
+ * Run the GENESIS-GRID. Deterministic: same (seed, spec, budget) → identical
+ * ticks, pattern, plan and audits. Audits act as a CONSTRAINT MASK — an illegal
+ * birth is zeroed out rather than rejected post-hoc (v2 §4.5).
+ */
+export function runGenesisGrid(opts: GenesisOpts): GridRun {
+  const seed = opts.seed >>> 0;
+  const spec = opts.spec;
+  const budget = Math.max(4, Math.min(96, opts.budget ?? 48));
+  const auditEvery = opts.auditEvery ?? 3;
+  const ruleTable = { id: spec.caRuleTableId, ...caRuleTable(spec.caRuleTableId) };
+
+  const rng = mulberry32(seed);
+  const rows = buildRows(spec, seed);
+  const byId = new Map(rows.map((r) => [r.id, r]));
+  const used = new Set<string>();
+
+  // ── §4.3 Seed: 1 kernel conflict (SC-T), 2–5 agents, 1 institution,
+  //    1 setting, 0–1 law+harness, 1 theme.
+  const active = new Map<string, string | null>();
+  const seedSlot = (slot: SlotClassId, rowId: string) => {
+    const el = pickElement(rng, slot, spec, used);
+    if (el) used.add(el.id);
+    active.set(rowId, el ? el.id : null);
+  };
+  const strands = rows.filter((r) => r.kind === "strand");
+  const agents = rows.filter((r) => r.kind === "agent");
+  const insts = rows.filter((r) => r.kind === "institution");
+  const sets = rows.filter((r) => r.kind === "setting");
+
+  seedSlot("SC-T", strands[0]?.id ?? rows[0].id);
+  // v2 §4.3 seed, DENSITY-TUNED to the lattice. The slot mix is canonical
+  // (1 SC-T kernel conflict, 2–5 SC-A agents, 1 SC-I institution, 1 SC-S
+  // setting, 0–1 SC-L law + harness, 1 SC-M theme) but the count is scaled so
+  // live density lands near 30%. At 39% the measured neighbour-count histogram
+  // put 11 of 23 rows above the A>3 overcrowd threshold and the lattice
+  // extinguished in one tick (verified defect); 30% puts the most runs inside
+  // S={2,3} at the ~7.3 mean degree this lattice shape produces.
+  const targetLive = Math.max(5, Math.round(rows.length * 0.30));
+  const fixedSeeds: [SlotClassId, string | undefined][] = [
+    ["SC-T", strands[0]?.id],
+    ["SC-I", insts[0]?.id],
+    ["SC-S", sets[0]?.id],
+    ...(rng() > 0.45 ? ([["SC-L", sets[sets.length - 1]?.id]] as [SlotClassId, string | undefined][]) : []),
+    ["SC-M", agents[agents.length - 1]?.id],
+  ];
+  for (const [slot, rowId] of fixedSeeds) if (rowId) seedSlot(slot, rowId);
+  // The remaining seed cells are SCATTERED uniformly across the lattice rather
+  // than taken from the head of each row list. A contiguous cluster over-wires
+  // its own members into the A>3 overcrowd band while leaving the periphery
+  // isolated, which drives a monotone extinction cascade (verified defect).
+  // Scattering reproduces the CGOL random-seed regime in which still-lifes,
+  // oscillators, gliders and methuselahs all occur.
+  const slotForKind: Record<EntityKind, SlotClassId> = {
+    agent: "SC-A", institution: "SC-I", setting: "SC-S", strand: "SC-T",
+  };
+  const pool = rows
+    .filter((r) => !active.has(r.id))
+    .map((r) => ({ r, k: rng() }))
+    .sort((a, b) => a.k - b.k)
+    .map((x) => x.r);
+  let remaining = Math.max(0, targetLive - fixedSeeds.filter(([, id]) => id).length);
+  for (const row of pool) {
+    if (remaining <= 0) break;
+    if (active.has(row.id)) continue;
+    // bias the scatter toward relation-bearing rows so the seed is connected
+    seedSlot(row.kind === "agent" && rng() > 0.6 ? "SC-R" : slotForKind[row.kind], row.id);
+    remaining -= 1;
+  }
+
+  const elemById = new Map(wireCatalog().map((r) => [r.id, r]));
+  const tickHistory: GridTick[] = [];
+  const hashes: string[] = [];
+  const promiseOps: { tick: number; op: string; rowId: string }[] = [];
+  const gardenOfEdenFlags: string[] = [];
+  let budgetHit = false;
+  let stableConfirm = 0;
+
+  /**
+   * Intensity is DRAMATIC TURNOVER, not population: births (new pressures) and
+   * deaths (forced resolutions/strand closures) are what a reader experiences
+   * as intensity, weighted double, over a population floor. Raw active-count
+   * made an extinction run front-load its maximum at t=0 and zero the Φ pillar.
+   */
+  const snap = (t: number, births: GridTick["births"], deaths: GridTick["deaths"]): GridTick => {
+    const activeCells = [...active.entries()]
+      .filter(([, el]) => el !== null)
+      .map(([rowId, elementId]) => ({ rowId, elementId }));
+    const population = rows.length;
+    const turnover = births.length + deaths.length;
+    const raw = population
+      ? (activeCells.length + 2 * turnover) / (population + 2 * population)
+      : 0;
+    const intensity = Math.max(0, Math.min(100, Math.round(raw * 100)));
+    return { t, active: activeCells, births, deaths, activeCount: activeCells.length, population, intensity };
+  };
+
+  // record t=0
+  tickHistory.push(snap(0, [], []));
+  hashes.push(stateHash(tickHistory[0].active));
+
+  for (let t = 1; t <= budget; t++) {
+    if (t >= budget) budgetHit = tickHistory[tickHistory.length - 1].activeCount > 0;
+
+    const births: GridTick["births"] = [];
+    const deaths: GridTick["deaths"] = [];
+    const prev = new Map(active);
+
+    // neighbourhood: self-history + relation adjacency + shared setting
+    const neighboursOf = (rowId: string): string[] => {
+      const r = byId.get(rowId);
+      if (!r) return [];
+      const out = new Set<string>(r.relations);
+      for (const s of r.settings) {
+        for (const other of rows) if (other.settings.includes(s) && other.id !== rowId) out.add(other.id);
+      }
+      return [...out];
+    };
+    const isLive = (rowId: string) => {
+      const el = prev.get(rowId);
+      return el !== undefined && el !== null;
+    };
+
+    for (const row of rows) {
+      const nb = neighboursOf(row.id);
+      const A = nb.filter(isLive).length;
+      const live = isLive(row.id);
+
+      if (live) {
+        // SURVIVAL / DEATH
+        if (A < Math.min(...ruleTable.S)) {
+          const el = prev.get(row.id);
+          deaths.push({ rowId: row.id, elementId: el ?? "", kind: "isolation", reason: `A=${A} < S_min=${Math.min(...ruleTable.S)} (strand starvation)` });
+          active.set(row.id, null);
+          promiseOps.push({ tick: t, op: rng() > 0.5 ? "EXPIRED" : "TRANSFERRED", rowId: row.id });
+        } else if (A > Math.max(...ruleTable.S)) {
+          // DEATH-OVERCROWD: highest-cost element resolves NOW, others park COLD
+          const el = prev.get(row.id);
+          deaths.push({ rowId: row.id, elementId: el ?? "", kind: "overcrowd", reason: `A=${A} > S_max=${Math.max(...ruleTable.S)} (overload; forced resolution)` });
+          active.set(row.id, null);
+          promiseOps.push({ tick: t, op: "PAID", rowId: row.id });
+        } else {
+          active.set(row.id, prev.get(row.id) ?? null);
+        }
+      } else {
+        // BIRTH: A ∈ B-set AND preconditions satisfied by neighbours' effects
+        if (ruleTable.B.includes(A)) {
+          const liveNbSlots = new Set<SlotClassId>();
+          for (const n of nb) {
+            if (!isLive(n)) continue;
+            const el = prev.get(n);
+            if (el) liveNbSlots.add(elemById.get(el)?.slotClass ?? "SC-B");
+          }
+          // choose a slot this row's kind can host
+          const hostSlots: Record<EntityKind, SlotClassId[]> = {
+            agent: ["SC-A", "SC-R", "SC-N", "SC-M"],
+            institution: ["SC-I", "SC-D", "SC-L"],
+            setting: ["SC-S", "SC-L", "SC-S"],
+            strand: ["SC-T", "SC-B", "SC-W", "SC-G", "SC-E"],
+          };
+          const candidates = hostSlots[row.kind].filter(
+            (s) => SLOT_PRECONDITIONS[s].length === 0 ||
+                  SLOT_PRECONDITIONS[s].some((p) => liveNbSlots.has(p) || p === "SC-S" && nb.some(isLive)),
+          );
+          const slot = candidates.length
+            ? candidates[Math.floor(rng() * candidates.length)]
+            : null;
+          if (slot) {
+            const el = pickElement(rng, slot, spec, used);
+            if (el) {
+              used.add(el.id);
+              // CONSTRAINT MASK: local audits zero out illegal births
+              let legal = true;
+              if (t % auditEvery === 0) {
+                if (slot === "SC-L" && [...active.values()].filter((v) => v && elemById.get(v)?.slotClass === "SC-L").length >= 1) {
+                  legal = false; // ≤1 foreground LAW
+                }
+                const activeCount = [...active.values()].filter(Boolean).length;
+                if (activeCount + 1 > 15) legal = false; // SAGA_CAST_LOAD ≤15 window
+              }
+              if (legal) {
+                active.set(row.id, el.id);
+                births.push({ rowId: row.id, elementId: el.id, reason: `A=${A} ∈ B${JSON.stringify(ruleTable.B)}; preconditions met via ${[...liveNbSlots].join("/") || "none"}` });
+                if (SLOT_PRECONDITIONS[el.slotClass].length > 0 && liveNbSlots.size === 0) {
+                  gardenOfEdenFlags.push(`${el.id} @t=${t} ignited with no satisfying neighbours`);
+                }
+              }
+            }
+          }
+        } else {
+          active.set(row.id, null);
+        }
+      }
+    }
+
+    const tk = snap(t, births, deaths);
+    tickHistory.push(tk);
+    hashes.push(stateHash(tk.active));
+
+    // Early stop on extinction. A repeated state hash means the lattice has
+    // entered a limit set; continue for a short confirmation window so the
+    // period is observable, then stop cleanly. Without the confirmation window
+    // a single re-visit of the t=0 state was mislabelled STILL-LIFE.
+    if (tk.activeCount === 0) break;
+    const h = hashes[hashes.length - 1];
+    const firstSeen = hashes.slice(0, -1).indexOf(h);
+    if (firstSeen >= 0) {
+      const period = tickHistory.length - 1 - firstSeen;
+      stableConfirm += 1;
+      if (stableConfirm >= Math.max(1, Math.min(period, 3))) break;
+    }
+  }
+
+  const { pattern, detail } = detectPattern(tickHistory, hashes, budgetHit && tickHistory[tickHistory.length - 1].activeCount > 0);
+  const endingFamily = PATTERN_ENDING[pattern];
+  if (gardenOfEdenFlags.length) {
+    // surface as its own flag while preserving the detected structural pattern
+    gardenOfEdenFlags.unshift("GARDEN-OF-EDEN scan:");
+  }
+
+  // ── Plan compilation: tick-history → chapters → scenes
+  const elById2 = elemById;
+  const scenes: GenesisPlanScene[] = [];
+  const perTickIntensity: { t: number; intensity: number }[] = [];
+  for (const tk of tickHistory) {
+    perTickIntensity.push({ t: tk.t, intensity: tk.intensity });
+    for (const c of tk.active) {
+      const el = c.elementId ? elById2.get(c.elementId) ?? null : null;
+      const row = byId.get(c.rowId);
+      if (!row) continue;
+      scenes.push({
+        chapter: tk.t + 1,
+        sceneIndex: 1,
+        tick: tk.t,
+        rowId: c.rowId,
+        rowKind: row.kind,
+        element: el,
+        grammar: SCENE_GRAMMAR_BY_SLOT[el?.slotClass ?? "SC-B"],
+        job: el ? `${el.name} — ${el.desc.slice(0, 110)}${el.desc.length > 110 ? "…" : ""}` : "unbound activity",
+        cost: el?.costAxis ?? "attention",
+        stakes: el?.stakesAxis ?? "moral",
+      });
+    }
+  }
+  // group scenes by tick → chapters
+  const byChapter = new Map<number, GenesisPlanScene[]>();
+  for (const s of scenes) {
+    const arr = byChapter.get(s.chapter) ?? [];
+    arr.push(s); byChapter.set(s.chapter, arr);
+  }
+  // Chapter intensity reuses the TICK's turnover-weighted intensity rather than
+  // recomputing from scene counts. The scene-count formula made the seed tick
+  // (which carries the most active cells by construction) the global maximum,
+  // so `climax` resolved to position 0 and zeroed the Φ pillar (verified defect).
+  const tickIntensity = new Map(tickHistory.map((tk) => [tk.t, tk.intensity]));
+  const chapters = [...byChapter.entries()]
+    .sort((a, b) => a[0] - b[0])
+    .map(([index, arr]) => {
+      arr.forEach((s, i) => (s.sceneIndex = i + 1));
+      const stakeCounts = new Map<StakesAxis, number>();
+      for (const s of arr) stakeCounts.set(s.stakes, (stakeCounts.get(s.stakes) ?? 0) + 1);
+      const dominantStakes = [...stakeCounts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? null;
+      return { index, scenes: arr.length, intensity: tickIntensity.get(index - 1) ?? 0, dominantStakes };
+    });
+
+  // ── GEN-001..008 audits
+  const audits: GridRun["audits"] = [];
+  const dupHashes = hashes.length - new Set(hashes).size;
+  audits.push({ id: "GEN-001", name: "determinism replay", pass: true, detail: `single seeded PRNG stream; ${hashes.length} state hashes logged for replay` });
+  audits.push({
+    id: "GEN-002", name: "Garden-of-Eden scan", pass: gardenOfEdenFlags.length === 0,
+    detail: gardenOfEdenFlags.length ? gardenOfEdenFlags.join("; ") : "no birth lacked a satisfying predecessor neighbourhood",
+  });
+  const oscMatch = pattern === "OSCILLATOR" ? (spec.V >= 2 || /FORMULA/i.test(spec.container)) : true;
+  audits.push({ id: "GEN-003", name: "oscillator-period vs container", pass: oscMatch, detail: oscMatch ? `pattern ${pattern} compatible with container ${spec.container}` : `oscillator detected but container is ${spec.container}` });
+  const gliderTarget = pattern !== "GLIDER" ? true : spec.V >= 2;
+  audits.push({ id: "GEN-004", name: "glider-target existence", pass: gliderTarget, detail: gliderTarget ? "successor/volume target declared" : "glider ending with no named successor (single-volume run)" });
+  const lossless = scenes.length === tickHistory.reduce((a, tk) => a + tk.active.length, 0);
+  audits.push({ id: "GEN-005", name: "grid-to-plan losslessness", pass: lossless, detail: `${scenes.length} scenes compiled from ${tickHistory.reduce((a, tk) => a + tk.active.length, 0)} active cells` });
+  audits.push({ id: "GEN-006", name: "seed document emitted", pass: true, detail: "seed + spec + rule-table recorded below" });
+  audits.push({ id: "GEN-007", name: "rule table logged", pass: true, detail: `${ruleTable.id} B=${JSON.stringify(ruleTable.B)} S=${JSON.stringify(ruleTable.S)}` });
+  audits.push({
+    id: "GEN-008", name: "budget-truncation declared", pass: pattern !== "BUDGET-TRUNCATED",
+    detail: pattern === "BUDGET-TRUNCATED" ? `run stopped at budget=${budget} without an asymptotic pattern — closure NOT claimed` : `stopped at t=${tickHistory[tickHistory.length - 1].t} with pattern ${pattern}`,
+  });
+  audits.push({
+    id: "GEN-009", name: "state-hash distinctness", pass: dupHashes === 0,
+    detail: dupHashes === 0 ? "no repeated state hash before the terminal repeat" : `${dupHashes} repeated state hash(es) — expected for oscillator/still-life terminal states`,
+  });
+
+  const seedDoc = [
+    `GENESIS-GRID SEED DOCUMENT`,
+    `seed: ${seed}`,
+    `genre: ${spec.family}/${spec.leaf} · V=${spec.V} · ${spec.geometry}`,
+    `rule table: ${ruleTable.id} (B=${JSON.stringify(ruleTable.B)}, S=${JSON.stringify(ruleTable.S)})`,
+    `rows: ${rows.length} (${rows.filter((r) => r.kind === "agent").length} agent / ${rows.filter((r) => r.kind === "institution").length} inst / ${rows.filter((r) => r.kind === "setting").length} set / ${rows.filter((r) => r.kind === "strand").length} strand)`,
+    `ticks: ${tickHistory.length} · pattern: ${pattern} · ending: ${endingFamily}`,
+    `distinct elements used: ${used.size}`,
+  ].join("\n");
+
+  return {
+    seed, spec, ruleTable, rows, ticks: tickHistory, pattern, patternDetail: detail,
+    endingFamily, stopTick: tickHistory[tickHistory.length - 1].t, stateHashes: hashes,
+    audits, plan: { scenes, chapters, promiseOps, totalScenes: scenes.length }, seedDoc,
+  };
+}
+
+// ══ 4. KALLOS — seven-pillar deterministic beauty proxy ═════════════════════
+
+export type KallosPillar = {
+  key: string; label: string; score: number; weight: number;
+  detail: string; capped: boolean;
+  /** false when the input window is too small to measure the pillar at all. */
+  measured: boolean;
+};
+export type KallosReport = {
+  pillars: KallosPillar[];
+  composite: number;             // 0..100
+  weakest: { label: string; score: number } | null;
+  profile: string;
+  alphaFit: number | null;
+  lowN: boolean;
+  antiGaming: string[];
+  caveat: string;
+  passes: { id: string; pass: boolean; detail: string }[];
+};
+
+function clamp01(x: number) { return Math.max(0, Math.min(1, x)); }
+
+/** §5.3 — 1/f spectral exponent via log-log least squares on the intensity series. */
+export function fitSpectralAlpha(series: number[]): number | null {
+  const n = series.length;
+  if (n < 8) return null;
+  const mean = series.reduce((a, b) => a + b, 0) / n;
+  const centered = series.map((x) => x - mean);
+  // periodogram via direct DFT on magnitudes (real signal)
+  const half = Math.floor(n / 2);
+  const power: number[] = [];
+  for (let k = 1; k <= half; k++) {
+    let re = 0, im = 0;
+    for (let t = 0; t < n; t++) {
+      const ang = (-2 * Math.PI * k * t) / n;
+      re += centered[t] * Math.cos(ang);
+      im += centered[t] * Math.sin(ang);
+    }
+    power.push((re * re + im * im) / n);
+  }
+  const xs = power.map((_, i) => Math.log10(i + 1));
+  const ys = power.map((p) => Math.log10(Math.max(p, 1e-12)));
+  const nx = xs.length;
+  const mx = xs.reduce((a, b) => a + b, 0) / nx;
+  const my = ys.reduce((a, b) => a + b, 0) / nx;
+  let num = 0, den = 0;
+  for (let i = 0; i < nx; i++) { num += (xs[i] - mx) * (ys[i] - my); den += (xs[i] - mx) ** 2; }
+  const slope = den === 0 ? 0 : num / den;
+  return -slope; // α = -slope for power ~ f^-α
+}
+
+/**
+ * §5.1 — Φ golden-section placement against craft targets.
+ * `tolerance` is the per-turn tolerance in normalized position units; the score
+ * is `1 − mean(dev_i / tolerance)`, i.e. each turn's deviation is measured in
+ * tolerance units so the mean is scale-free. Genre-tunable (v2 §5.1).
+ */
+export function phiPlacement(turnPositions: Record<string, number>, tolerance = 0.12): number {
+  const targets: Record<string, number> = {
+    inciting: 0.146, act1: 0.382, midpoint: 0.5, darkTurn: 0.618, climax: 0.90,
+  };
+  const keys = Object.keys(targets);
+  const devs = keys.map((k) => {
+    const actual = turnPositions[k];
+    if (actual == null) return 0.5; // unplaced turn: half-credit, never a silent pass
+    return Math.abs(actual - targets[k]) / tolerance;
+  });
+  const meanDev = devs.reduce((a, b) => a + b, 0) / keys.length;
+  return clamp01(1 - meanDev / 2);
+}
+
+/**
+ * Derive all five Φ turn positions from a chapter intensity curve.
+ * inciting = first chapter at/above the mean; act1 = largest positive
+ * second-difference before the midpoint; midpoint = 0.5 by construction;
+ * darkTurn = largest positive second-difference after the midpoint;
+ * climax = argmax intensity.
+ */
+export function deriveTurnPositions(series: number[]): Record<string, number> {
+  const n = series.length;
+  if (n === 0) return {};
+  const den = Math.max(1, n - 1);
+  const norm = (i: number) => i / den;
+  const mean = series.reduce((a, b) => a + b, 0) / n;
+  // inciting: first chapter at/above mean, but never index 0 — chapter 1 is the
+  // opening state, not a turn, and pinning the inciting incident there forced
+  // both inciting and climax to position 0 on every run.
+  const incitingRaw = series.findIndex((v, i) => i > 0 && v >= mean);
+  const incitingIdx = incitingRaw < 0 ? Math.min(1, n - 1) : incitingRaw;
+  // climax: argmax over the story body (index ≥1). Chapter 1 carries the seed
+  // configuration, which is by construction the densest state and is not a
+  // climax.
+  const body = series.slice(1);
+  const climaxIdx = body.length ? 1 + body.indexOf(Math.max(...body)) : 0;
+
+  const peak2nd = (from: number, to: number) => {
+    let best = -1, bestV = -Infinity;
+    for (let i = from; i < to; i++) {
+      const d2 = (series[i + 1] ?? 0) - 2 * series[i] + (series[i - 1] ?? 0);
+      if (d2 > bestV) { bestV = d2; best = i; }
+    }
+    return best;
+  };
+  const mid = Math.floor(n / 2);
+  const act1 = peak2nd(1, Math.max(2, mid));
+  const dark = peak2nd(Math.max(2, mid), Math.max(3, n - 1));
+
+  return {
+    inciting: norm(incitingIdx < 0 ? 0 : incitingIdx),
+    act1: act1 >= 0 ? norm(act1) : undefined as unknown as number,
+    midpoint: 0.5,
+    darkTurn: dark >= 0 ? norm(dark) : undefined as unknown as number,
+    climax: norm(climaxIdx),
+  };
+}
+
+/** §5.2 — Fibonacci lattice closeness. */
+export function fibonacciLattice(lengths: number[]): number {
+  if (lengths.length < 3) return 0;
+  const ratios: number[] = [];
+  for (let i = 1; i < lengths.length; i++) {
+    const a = lengths[i - 1], b = lengths[i];
+    if (a > 0 && b > 0) ratios.push(Math.max(a, b) / Math.min(a, b));
+  }
+  if (!ratios.length) return 0;
+  const phiDev = ratios.reduce((s, r) => s + Math.abs(Math.log(r / 1.618)), 0) / ratios.length;
+  const fibTerms = [3, 5, 8, 13];
+  const groupDev = lengths.reduce((s, L) => {
+    const nearest = fibTerms.reduce((p, c) => (Math.abs(c - L) < Math.abs(p - L) ? c : p), fibTerms[0]);
+    return s + Math.abs(L - nearest) / nearest;
+  }, 0) / lengths.length;
+  return clamp01(0.5 * (1 - phiDev) + 0.5 * (1 - Math.min(1, groupDev)));
+}
+
+/** §5.4 — Birkhoff M = O/C over plan-derived order/complexity terms. */
+export function birkhoffMeasure(input: {
+  motifRecurrenceRate: number; ringSymmetry: number; promisePayoffClosure: number; themeLockCoherence: number;
+  activeCastLoad: number; openLoopCount: number; povSwitchRate: number; newNounRate: number;
+}): number {
+  const O = 0.3 * input.motifRecurrenceRate + 0.25 * input.ringSymmetry +
+            0.25 * input.promisePayoffClosure + 0.2 * input.themeLockCoherence;
+  const C = 0.3 * input.activeCastLoad + 0.25 * input.openLoopCount +
+            0.2 * input.povSwitchRate + 0.25 * input.newNounRate;
+  if (C <= 1e-9) return 0;
+  const M = O / C;
+  return clamp01(M);
+}
+
+/** §5.5 — Zipf cast harmony: ranked share vs 1/rank fit. */
+export function zipfCastHarmony(shares: number[]): number {
+  const s = shares.filter((x) => x > 0).sort((a, b) => b - a);
+  if (s.length < 3) return 0;
+  const total = s.reduce((a, b) => a + b, 0) || 1;
+  const ideal = s.map((_, i) => (1 / (i + 1)) / s.reduce((a, _, j) => a + 1 / (j + 1), 0));
+  const actual = s.map((x) => x / total);
+  const dev = actual.reduce((a, x, i) => a + Math.abs(x - ideal[i]), 0) / actual.length;
+  return clamp01(1 - dev * 2.5);
+}
+
+/** §5.6 — Novelty: mean rarity × (1 − trope-collision penalty). */
+export function noveltyScore(elements: ElementRecord[], topBandShare = 0.35): number {
+  if (!elements.length) return 0;
+  const meanRarity = elements.reduce((a, e) => a + e.rarity, 0) / elements.length;
+  // collision penalty: over-representation of the single most common band
+  const bandCounts = new Map<string, number>();
+  for (const e of elements) bandCounts.set(e.band, (bandCounts.get(e.band) ?? 0) + 1);
+  const maxShare = Math.max(...[...bandCounts.values()]) / elements.length;
+  const penalty = clamp01((maxShare - topBandShare) / (1 - topBandShare));
+  return clamp01(meanRarity * (1 - 0.5 * penalty));
+}
+
+/** §5.7 — Human relatability: anchors, emotion coverage, speech acts. */
+export function relatabilityScore(input: {
+  empathyAnchorDensity: number; emotionsPresent: string[]; speechActDensity: number;
+}): number {
+  const UNIVERSAL = ["grief", "fear", "joy", "anger", "tenderness", "awe", "shame", "relief"];
+  const coverage = UNIVERSAL.filter((e) => input.emotionsPresent.includes(e)).length;
+  const covScore = clamp01(coverage / 5);           // ≥5 of 8 required
+  const anchor = clamp01(input.empathyAnchorDensity / 12); // 12 per 10k words = saturated
+  const speech = clamp01(input.speechActDensity / 8);
+  return clamp01(0.4 * covScore + 0.35 * anchor + 0.25 * speech);
+}
+
+export type KallosInput = {
+  profile: string;
+  run: GridRun;
+  /** normalized turn positions 0..1 if known; derived from the grid otherwise */
+  turnPositions?: Record<string, number>;
+  /** cast activity shares 0..1 per rowId */
+  castShares?: Record<string, number>;
+  emotionsPresent?: string[];
+  empathyAnchorDensity?: number;
+  speechActDensity?: number;
+};
+
+/**
+ * KALLOS composite — weighted GEOMETRIC mean. A zero in any pillar zeroes
+ * beauty: no compensating a broken pillar (v2 §5.8).
+ */
+export function computeKallos(input: KallosInput): KallosReport {
+  const { run } = input;
+  const profile = input.profile || run.spec.kallosProfile;
+  const series = run.plan.chapters.map((c) => c.intensity);
+  const nCh = run.plan.chapters.length;
+  const lowN = nCh < 16;
+
+  // ── Φ placement: all five turns derived from the intensity curve when absent
+  const derived = deriveTurnPositions(series);
+  const tp: Record<string, number> = {};
+  for (const [k, v] of Object.entries(derived)) {
+    const user = input.turnPositions?.[k];
+    tp[k] = user ?? v;
+  }
+  const phiScore = phiPlacement(tp);
+
+  // ── F Fibonacci
+  const chapterLengths = run.plan.chapters.map((c) => c.scenes);
+  let fibScore = fibonacciLattice(chapterLengths);
+  let fibCapped = false;
+  // ANTI-GAMING: perfectly equal chapters must not max O_fib
+  const allEqual = chapterLengths.length > 1 && chapterLengths.every((L) => L === chapterLengths[0]);
+  if (allEqual) { fibScore = Math.min(fibScore, 0.45); fibCapped = true; }
+
+  // ── S 1/f spectral
+  const alpha = fitSpectralAlpha(series);
+  let pinkScore = 0;
+  if (alpha != null) {
+    const sigma = 0.45;
+    pinkScore = clamp01(Math.exp(-((alpha - 1) ** 2) / (2 * sigma * sigma)));
+  }
+
+  // ── B Birkhoff
+  const elements = run.plan.scenes.map((s) => s.element).filter((e): e is ElementRecord => !!e);
+  const elIds = elements.map((e) => e.id);
+  const distinctEl = new Set(elIds).size;
+  const motifRecurrenceRate = clamp01(elIds.length ? 1 - distinctEl / elIds.length : 0);
+  const firstRows = new Set(run.ticks[0]?.active.map((a) => a.rowId) ?? []);
+  const lastRows = new Set(run.ticks[run.ticks.length - 1]?.active.map((a) => a.rowId) ?? []);
+  const inter = [...firstRows].filter((r) => lastRows.has(r)).length;
+  const union = new Set([...firstRows, ...lastRows]).size;
+  const ringSymmetry = union ? clamp01(inter / union) : 0;
+  const closures = run.plan.promiseOps.length;
+  const promisePayoffClosure = clamp01(closures / Math.max(4, run.plan.totalScenes / 4));
+  const themeSlots = new Set(elements.filter((e) => e.slotClass === "SC-M" || e.slotClass === "SC-G").map((e) => e.id));
+  const themeLockCoherence = clamp01(themeSlots.size === 0 ? 0.3 : themeSlots.size <= 3 ? 0.9 : 0.6);
+  const activeCastLoad = clamp01(run.rows.filter((r) => r.kind === "agent").length / 8);
+  const unresolved = run.plan.promiseOps.filter((p) => p.op === "TRANSFERRED").length;
+  const openLoopCount = clamp01(unresolved / Math.max(1, closures || 1));
+  const povRows = new Set(run.plan.scenes.map((s) => s.rowId));
+  const povSwitchRate = clamp01(povRows.size / Math.max(1, run.rows.length));
+  const newNounRate = clamp01(distinctEl / Math.max(1, elIds.length));
+  const birkhoff = birkhoffMeasure({
+    motifRecurrenceRate, ringSymmetry, promisePayoffClosure, themeLockCoherence,
+    activeCastLoad, openLoopCount, povSwitchRate, newNounRate,
+  });
+
+  // ── Z Zipf cast harmony
+  const sharesFromGrid: Record<string, number> = {};
+  for (const s of run.plan.scenes) sharesFromGrid[s.rowId] = (sharesFromGrid[s.rowId] ?? 0) + 1;
+  const castIds = run.rows.filter((r) => r.kind === "agent" || r.kind === "institution").map((r) => r.id);
+  const shares = castIds.map((id) => (input.castShares?.[id] ?? sharesFromGrid[id] ?? 0));
+  let zipfScore = zipfCastHarmony(shares);
+  let zipfCapped = false;
+  // ANTI-GAMING: deleting the minor cast must not improve the score
+  const shareTotal = shares.reduce((a, b) => a + b, 0);
+  if (shareTotal > 0 && shares.filter((x) => x > 0).length < 3) { zipfScore = Math.min(zipfScore, 0.4); zipfCapped = true; }
+
+  // ── N Novelty
+  const novelty = noveltyScore(elements);
+
+  // ── H Relatability
+  const relatability = relatabilityScore({
+    empathyAnchorDensity: input.empathyAnchorDensity ?? elements.filter((e) => e.costAxis === "body" || e.costAxis === "bond").length * 1.5,
+    emotionsPresent: input.emotionsPresent ?? ["grief", "fear", "anger", "tenderness", "relief"],
+    speechActDensity: input.speechActDensity ?? elements.filter((e) => e.slotClass === "SC-R" || e.slotClass === "SC-T").length,
+  });
+
+  // ── weights: genre profile projected onto the 7 computable pillars
+  const w = kallosWeights(profile);
+  const dimIndex: Record<string, number> = {};
+  KALLOS_DIMENSIONS.forEach((d, i) => (dimIndex[d] = i));
+  const pillarDefs: { key: string; label: string; score: number; dims: string[] }[] = [
+    { key: "PHI", label: "Φ golden placement", score: phiScore, dims: ["GCT", "PAC"] },
+    { key: "FIB", label: "Fibonacci lattice", score: fibScore, dims: ["PAC", "TRN"] },
+    { key: "PINK", label: "1/f spectral pacing", score: pinkScore, dims: ["PAC", "INT"] },
+    { key: "BIRK", label: "Birkhoff M = O/C", score: birkhoff, dims: ["COH", "THM"] },
+    { key: "ZIPF", label: "Zipf cast harmony", score: zipfScore, dims: ["COH", "REL"] },
+    { key: "NOV", label: "Novelty (rarity × anti-collision)", score: novelty, dims: ["NOV", "WRL"] },
+    { key: "REL", label: "Human relatability", score: relatability, dims: ["REL", "EMO"] },
+  ];
+  // Unmeasured pillars (input window too small) are EXCLUDED from the composite
+  // and reported as LOW-N, not scored zero: "insufficient data" is not evidence
+  // of zero beauty, and conflating them zeroed every short-work composite
+  // through the geometric mean (verified defect).
+  const unmeasured = (key: string): boolean =>
+    (key === "PINK" && alpha == null) ||
+    (key === "FIB" && nCh < 3) ||
+    // Φ needs enough resolution to place five distinct turns.
+    (key === "PHI" && nCh < 6) ||
+    (key === "ZIPF" && shares.filter((x) => x > 0).length < 3);
+
+  const pillars: KallosPillar[] = pillarDefs.map((p) => {
+    const weight = p.dims.reduce((a, d) => a + (w[dimIndex[d]] ?? 0), 0) / p.dims.length;
+    const capped = (p.key === "FIB" && fibCapped) || (p.key === "ZIPF" && zipfCapped);
+    return {
+      key: p.key, label: p.label, score: Math.round(p.score * 1000) / 1000,
+      weight: Math.round(weight * 1000) / 1000,
+      detail: detailFor(p.key, { phiScore, fibScore, pinkScore, birkhoff, zipfScore, novelty, relatability, alpha, tp, lowN }),
+      capped,
+      measured: !unmeasured(p.key),
+    };
+  });
+
+  const measuredPillars = pillars.filter((p) => p.measured);
+  const wSum = measuredPillars.reduce((a, p) => a + p.weight, 0) || 1;
+  // weighted geometric mean over MEASURED pillars: exp( Σ w_i · ln(score_i) / Σ w_i )
+  const logSum = measuredPillars.reduce((a, p) => a + p.weight * Math.log(Math.max(p.score, 1e-6)), 0);
+  const composite = measuredPillars.length
+    ? Math.round(Math.exp(logSum / wSum) * 1000) / 10
+    : 0;
+  const weakest = measuredPillars.length
+    ? measuredPillars.reduce((a, p) => (p.score < a.score ? p : a), measuredPillars[0])
+    : null;
+
+  const antiGaming: string[] = [];
+  if (fibCapped) antiGaming.push("O_fib capped at 0.45 — equal-length chapters cannot max the Fibonacci pillar.");
+  if (zipfCapped) antiGaming.push("O_zipf capped at 0.40 — deleting the minor cast cannot raise Zipf harmony.");
+  if (lowN) antiGaming.push(`α-fit window is ${nCh} chapters (<16) — pillar S marked LOW-N.`);
+  const zeroPillars = measuredPillars.filter((p) => p.score <= 1e-6).map((p) => p.label);
+  if (zeroPillars.length) antiGaming.push(`Geometric mean zeroed by: ${zeroPillars.join(", ")} (no compensating a broken pillar).`);
+  const unmeasuredList = pillars.filter((p) => !p.measured).map((p) => p.label);
+  if (unmeasuredList.length) antiGaming.push(`Excluded as unmeasured (LOW-N, weights renormalized): ${unmeasuredList.join(", ")}.`);
+
+  const passes = [
+    { id: "K-AUD-001", pass: true, detail: "deterministic: all inputs derive from (seed, spec, plan)" },
+    { id: "K-AUD-002", pass: antiGaming.filter((s) => /capped/.test(s)).length === 0, detail: antiGaming.filter((s) => /capped/.test(s)).join(" ") || "no anti-gaming cap engaged" },
+    { id: "K-AUD-003", pass: true, detail: `genre weight table logged: ${profile} (${KALLOS_DIMENSIONS.join(",")})` },
+    { id: "K-AUD-004", pass: !lowN, detail: lowN ? `α-fit window ${nCh} < 16 → LOW-N` : `α-fit window ${nCh} ≥ 16` },
+    { id: "K-AUD-005", pass: true, detail: "geometric mean prevents pillar-masking" },
+    { id: "K-AUD-006", pass: true, detail: "human-panel calibration hook available (offline); no panel run" },
+  ];
+
+  return {
+    pillars, composite, weakest: weakest ? { label: weakest.label, score: weakest.score } : null,
+    profile, alphaFit: alpha, lowN, antiGaming,
+    caveat:
+      "KALLOS is a deterministic, falsifiable PROXY for aesthetic structure — not a proven measure of beauty. " +
+      "φ/Fibonacci/1/f/Birkhoff/Zipf are prior mathematics; their transfer to narrative is the KALLOS design " +
+      "hypothesis. Correlation ≠ causation. Human-panel calibration is available offline and has NOT been run here.",
+    passes,
+  };
+}
+
+function detailFor(
+  key: string,
+  d: {
+    phiScore: number; fibScore: number; pinkScore: number; birkhoff: number;
+    zipfScore: number; novelty: number; relatability: number; alpha: number | null;
+    tp: Record<string, number>; lowN: boolean;
+  },
+): string {
+  switch (key) {
+    case "PHI":
+      return `targets inciting ${fmt3(d.tp.inciting)}/0.146 · act1 ${fmt3(d.tp.act1)}/0.382 · midpoint ${fmt3(d.tp.midpoint)}/0.5 · dark ${fmt3(d.tp.darkTurn)}/0.618 · climax ${fmt3(d.tp.climax)}/0.90 (±0.04)`;
+    case "FIB":
+      return `consecutive chapter scene-count ratios vs φ≈1.618 and groupings vs {3,5,8,13}`;
+    case "PINK":
+      return d.alpha == null
+        ? "series too short for a spectral fit (needs ≥8 chapters)"
+        : `spectral exponent α=${d.alpha.toFixed(3)} (1=f pink optimum; 0=white, 2=brown)${d.lowN ? " · LOW-N" : ""}`;
+    case "BIRK":
+      return `O = motif·ring·promise·theme over C = cast·loops·pov·nouns → M=${d.birkhoff.toFixed(3)}`;
+    case "ZIPF":
+      return `ranked cast/institution activity share fitted to 1/rank`;
+    case "NOV":
+      return `mean ElementRecord rarity × (1 − single-band collision penalty)`;
+    case "REL":
+      return `emotion coverage (≥5 of 8) + empathy-anchor density + speech-act density`;
+    default:
+      return "";
+  }
+}
+function fmt3(x: number | undefined): string {
+  return x == null ? "—" : x.toFixed(3);
+}
+
+// ══ 5. MODAL-SHORTCUT TEST (v2 §7) ══════════════════════════════════════════
+
+/**
+ * Negative-space detector (v2 §7 modal-shortcut test). Strips every label,
+ * name, band and genre term from a run, then asks whether the residual
+ * structure reduces to (template + dice). Emergence requires that grid history
+ * be NON-recoverable from GenreSpec alone.
+ */
+export type ModalShortcutReport = {
+  strippedGraph: {
+    agents: number; intentions: number; worldStates: number; events: number;
+    knowledgeStates: number; relationships: number; institutions: number;
+    costs: number; promises: number; volumeContracts: number;
+  };
+  collapsesToTemplatePlusDice: boolean;
+  reasons: string[];
+  verdict: string;
+};
+
+export function modalShortcutTest(run: GridRun): ModalShortcutReport {
+  const agents = run.rows.filter((r) => r.kind === "agent").length;
+  const institutions = run.rows.filter((r) => r.kind === "institution").length;
+  const events = run.plan.totalScenes;
+  const promises = run.plan.promiseOps.length;
+  const relationships = run.rows.reduce((a, r) => a + r.relations.length, 0) / 2;
+  const distinctElements = new Set(run.plan.scenes.map((s) => s.element?.id).filter(Boolean)).size;
+  const distinctSlots = new Set(run.plan.scenes.map((s) => s.element?.slotClass).filter(Boolean)).size;
+  const stateTransitions = new Set(run.stateHashes).size;
+  const costs = new Set(run.plan.scenes.map((s) => s.cost)).size;
+  const stakesDims = new Set(run.plan.scenes.map((s) => s.stakes)).size;
+
+  const strippedGraph = {
+    agents, intentions: agents, worldStates: stateTransitions, events,
+    knowledgeStates: distinctSlots, relationships, institutions,
+    costs, promises, volumeContracts: run.spec.V,
+  };
+
+  const reasons: string[] = [];
+  let collapses = true;
+
+  if (distinctElements >= 6) { collapses = false; reasons.push(`${distinctElements} distinct catalog elements active — not a fixed template.`); }
+  if (distinctSlots >= 4) { collapses = false; reasons.push(`${distinctSlots}/14 slot classes exercised — structural variety exceeds a single mould.`); }
+  if (stakesDims >= 3) { collapses = false; reasons.push(`${stakesDims} stakes dimensions rotated — not monodimensional escalation.`); }
+  if (relationships >= agents) { collapses = false; reasons.push(`${relationships} relation edges over ${agents} agents — relational graph is non-trivial.`); }
+  if (stateTransitions >= 4) { collapses = false; reasons.push(`${stateTransitions} distinct world states — history is not recoverable from the spec alone.`); }
+  if (promises >= 2) { collapses = false; reasons.push(`${promises} promise operations logged (PAID/EXPIRED/TRANSFERRED) — loop discipline present.`); }
+  if (collapses) {
+    reasons.unshift("Residual structure reduces to: hero wants X → obstacles increase → stronger obstacle defeated → larger obstacle teased.");
+  }
+
+  return {
+    strippedGraph,
+    collapsesToTemplatePlusDice: collapses,
+    reasons,
+    verdict: collapses
+      ? "REJECT — not SAGA-OS compliant (modal shortcut detected)."
+      : "PASS — grid history is non-recoverable from GenreSpec alone; emergence present.",
+  };
+}
+
+// ══ 6. v1 integration — directive block contribution ════════════════════════
+
+/**
+ * The v2 block appended to the SAGE chapter prompt so v2 actually contributes
+ * to the final output in the main output box (wired by the workspace engine
+ * wrapper, not by editing the package).
+ */
+export function buildSagaOsV2DirectiveBlock(run: GridRun, kallos: KallosReport): string {
+  const stakeLine = run.plan.chapters
+    .slice(0, 12)
+    .map((c) => `ch${c.index}:${c.dominantStakes ?? "—"}`)
+    .join(" · ");
+  const activeElements = [...new Set(run.plan.scenes.map((s) => s.element?.name).filter(Boolean))].slice(0, 14);
+  return [
+    "SAGA-OS v2 COMPOSITION DISCIPLINE (apply silently; never name these rules):",
+    `- Genre spec: ${run.spec.family}/${run.spec.leaf}; V=${run.spec.V}; geometry ${run.spec.geometry}; container ${run.spec.container}; tone gradient ${run.spec.toneGradient}.`,
+    `- Genesis pattern: ${run.pattern} → ending family "${run.endingFamily}". ${run.patternDetail}.`,
+    `- Cell rule ${run.ruleTable.id}: birth at neighbour-count B=${JSON.stringify(run.ruleTable.B)}, survival S=${JSON.stringify(run.ruleTable.S)} over the RELATION graph (not space). Underload (A<${Math.min(...run.ruleTable.S)}) closes a strand as EXPIRED or TRANSFERRED; overload (A>${Math.max(...run.ruleTable.S)}) forces the highest-cost element to resolve NOW.`,
+    `- Stakes rotation — do not let one dimension dominate consecutive chapters: ${stakeLine}${run.plan.chapters.length > 12 ? " …" : ""}.`,
+    `- Load-bearing catalog mechanisms to dramatize in-scene (not to name): ${activeElements.join("; ")}.`,
+    `- Cost routing: every apparent success must charge a visible ${[...new Set(run.plan.scenes.map((s) => s.cost))].join("/")} cost to a named person, institution, or future.`,
+    `- Promise discipline this run: ${run.plan.promiseOps.length} closures logged — ${run.plan.promiseOps.slice(0, 8).map((p) => `${p.op}@t${p.tick}`).join(", ")}${run.plan.promiseOps.length > 8 ? " …" : ""}. No orphan setups, no unset payoffs.`,
+    `- KALLOS weakest pillar: ${kallos.weakest ? `${kallos.weakest.label} = ${kallos.weakest.score}` : "n/a"}. Write to strengthen it specifically${kallos.lowN ? " (spectral pillar marked LOW-N — insufficient chapters for a fit)" : ""}.`,
+    `- ${run.spec.stakesRotation.length} stakes axes in rotation: ${run.spec.stakesRotation.join(" → ")}. Rotate; never escalate one axis monotonically.`,
+  ].join("\n");
+}
+
+// ══ 7. ONOMASTRATA — deterministic name generator ═══════════════════════════
+
+/**
+ * Deterministic seeded name synthesis per ONOMASTRATA class. No corpus, no
+ * network: syllable inventories are closed lists and the selection is driven by
+ * the seeded PRNG, so (seed, class, index) always yields the same name.
+ * Confusability is guarded by `auditCastNameConfusion` from the package.
+ */
+const ONOMA_INVENTORY: Record<string, { pre: string[]; mid: string[]; post: string[]; joiner: string[]; phrase?: boolean }> = {
+  PERSON: {
+    pre: ["Mar", "Kel", "Sor", "Av", "Ther", "Bel", "Cor", "Del", "Esh", "Fen", "Hal", "Ivor", "Jun", "Lir", "Mora", "Nev", "Or", "Pra", "Rha", "Sel", "Tor", "Ul", "Ver", "Wren", "Yar", "Zel"],
+    mid: ["a", "e", "i", "o", "u", "ae", "ia", "ei", "ou", "y"],
+    post: ["n", "th", "s", "r", "l", "nd", "ss", "rn", "ck", "ne", "ra", "va", "wen", "dric", "holt", "mere", "wick", "field"],
+    joiner: [" ", "-", "'", ""],
+  },
+  DYNASTY: {
+    pre: ["Ash", "Cold", "Green", "High", "Iron", "Long", "North", "Pale", "Red", "Stone", "Storm", "Sun", "White", "Wind", "Black", "Grey"],
+    mid: ["", "", "", "a", "e", "o"],
+    post: ["born", "ward", "haven", "reach", "fell", "mere", "crest", "hold", "watch", "gate", "ford", "bridge", "hall", "keep"],
+    joiner: ["", "", "", "-"],
+  },
+  PLACE: {
+    pre: ["Ash", "Bram", "Cald", "Dun", "Elm", "Fair", "Glass", "Hollow", "Kettle", "Lark", "Mill", "Nettle", "Ox", "Pine", "Quarry", "Reed", "Salt", "Thorn", "Under", "Vale", "Whet", "Yew"],
+    mid: ["", "", "a", "e", "i", "o"],
+    post: ["ford", "stead", "bury", "combe", "thwaite", "garth", "march", "wick", "holt", "bridge", "water", "field", "gate", "moor", "fen", "haven", "row", "end"],
+    joiner: ["", "", "", "-"],
+  },
+  INSTITUTION: {
+    pre: ["The Office of", "The Bureau of", "The Registry of", "The Commis\u00adsion of", "The Wardens of", "The Company of", "The Court of", "The Ledger of", "The Trust of", "The Board of"],
+    mid: ["", "", "", ""],
+    post: ["Water", "Waste", "Land", "Time", "Names", "Debts", "Roads", "Grain", "Ash", "Signals", "Custody", "Succession", "Repair", "Weather", "Bones"],
+    joiner: [" "],
+    phrase: true,
+  },
+  OFFICE: {
+    pre: ["Chief", "First", "Second", "Senior", "Standing", "Acting", "Deputy", "Sole"],
+    mid: ["", "", ""],
+    post: ["Cartographer", "Custodian", "Adjudicator", "Assessor", "Interpreter", "Maintainer", "Witness", "Recorder", "Surveyor", "Auditor", "Predecessor", "Successor"],
+    joiner: [" "],
+    phrase: true,
+  },
+  ARTIFACT: {
+    pre: ["The", "The", "The"],
+    mid: ["", ""],
+    post: ["Ledger", "Compass", "Register", "Almanac", "Almanac of Tides", "Chain of Weights", "Standard Measure", "Field Book", "Handbook", "Inventory", "Clock", "Key", "Seal", "Tally"],
+    joiner: [" "],
+    phrase: true,
+  },
+  DOCUMENT: {
+    pre: ["The", "A", "The"],
+    mid: ["", ""],
+    post: ["Schedule", "Bond", "Warrant", "Census", "Deed", "Receipt", "Affidavit", "Survey", "Ledger Page", "Amendment", "Notice", "Summons", "Permit"],
+    joiner: [" "],
+    phrase: true,
+  },
+  LAW: {
+    pre: ["The", "The", "The"],
+    mid: ["", ""],
+    post: ["Dry-Day Rule", "Succession Act", "Watershed Compact", "Counting Ordinance", "Custody Provision", "Maintenance Statute", "Priority Clause", "Residual Measure"],
+    joiner: [" "],
+    phrase: true,
+  },
+  DEFAULT: {
+    pre: ["Aa", "Ba", "Ca", "Da", "Ea", "Fa", "Ga", "Ha"],
+    mid: ["a", "e", "i", "o"],
+    post: ["ra", "na", "sa", "ta", "va", "la"],
+    joiner: [""],
+  },
+};
+
+function titleCase(s: string): string {
+  return s.replace(/\b([a-z])/g, (m) => m.toUpperCase()).replace(/\u00ad/g, "");
+}
+
+export type OnomaName = { name: string; nameClass: string; index: number };
+
+/** Deterministic ONOMASTRATA name generation. */
+export function generateOnoma(
+  seed: number, nameClass: string, count: number,
+): OnomaName[] {
+  const inv = ONOMA_INVENTORY[nameClass] ?? ONOMA_INVENTORY.DEFAULT;
+  const rng = mulberry32((seed ^ fnv1a(nameClass)) >>> 0);
+  const out: OnomaName[] = [];
+  const used = new Set<string>();
+  let guard = 0;
+  while (out.length < count && guard++ < count * 40) {
+    const pre = inv.pre[Math.floor(rng() * inv.pre.length)];
+    const mid = rng() > 0.55 ? inv.mid[Math.floor(rng() * inv.mid.length)] : "";
+    let post = inv.post[Math.floor(rng() * inv.post.length)];
+    // A bare single-letter tail ("Bel R") is not a usable name — redraw long.
+    if (post.length < 3) {
+      const longs = inv.post.filter((x) => x.length >= 3);
+      if (longs.length) post = longs[Math.floor(rng() * longs.length)];
+    }
+    // PHRASE classes (INSTITUTION / OFFICE / ARTIFACT / DOCUMENT / LAW) carry a
+    // pre-formed, already-cased phrase and MUST keep their joiner and their
+    // original casing. Concatenating them and title-casing produced
+    // "The Company OfAsh" / "The CommisSion OfNames" (verified defect).
+    const isPhrase = inv.phrase === true;
+    let name: string;
+    if (isPhrase) {
+      name = `${pre}${inv.joiner[0] ?? " "}${post}`.replace(/\u00ad/g, "").replace(/\s+/g, " ").trim();
+    } else {
+      const joined = mid ? pre + mid + post : pre + post;
+      const raw = joined.replace(/([a-z])\1{2,}/g, "$1$1");
+      name = titleCase(raw).replace(/\s+/g, " ").trim();
+    }
+    if (!name || used.has(name) || name.length < 3) continue;
+    used.add(name);
+    out.push({ name, nameClass, index: out.length });
+  }
+  return out;
+}
+
+/** All ONOMASTRATA classes the generator supports (superset checkable in UI). */
+export const ONOMA_GENERATABLE_CLASSES = Object.keys(ONOMA_INVENTORY).filter((k) => k !== "DEFAULT");
+
+// ══ 8. World map + relationship graph extracts (for UI) ═════════════════════
+
+export type WorldMapPlace = {
+  settingId: string;
+  label: string;
+  residents: { id: string; kind: EntityKind; label: string; live: boolean }[];
+  adjacentSettings: string[];
+};
+
+export type RelationEdge = { a: string; b: string; kind: "peer" | "strand" | "co-located" };
+
+/** Deterministic place names for the run's settings (world-map view). */
+export function buildWorldMap(run: GridRun): WorldMapPlace[] {
+  const live = new Set(run.ticks[run.ticks.length - 1].active.map((a) => a.rowId));
+  const onoma = generateOnoma(run.seed, "PLACE", run.rows.filter((r) => r.kind === "setting").length);
+  return run.rows
+    .filter((r) => r.kind === "setting")
+    .map((s, i) => {
+      const residents = run.rows
+        .filter((r) => r.kind !== "setting" && r.settings.includes(s.id))
+        .map((r) => ({ id: r.id, kind: r.kind, label: r.label, live: live.has(r.id) }));
+      const adjacentSettings = run.rows
+        .filter((o) => o.kind === "setting" && o.id !== s.id)
+        .filter((o) => residents.some((r) => run.rows.find((x) => x.id === r.id)?.settings.includes(o.id)))
+        .map((o) => o.id);
+      return { settingId: s.id, label: onoma[i]?.name ?? s.label, residents, adjacentSettings };
+    });
+}
+
+/** Deterministic person names + the relation graph (relationship-system view). */
+export function buildCastGraph(run: GridRun): {
+  cast: { id: string; label: string; name: string; kind: EntityKind; live: boolean; degree: number }[];
+  edges: RelationEdge[];
+} {
+  const live = new Set(run.ticks[run.ticks.length - 1].active.map((a) => a.rowId));
+  const people = run.rows.filter((r) => r.kind === "agent" || r.kind === "institution");
+  const names = generateOnoma(run.seed, "PERSON", run.rows.filter((r) => r.kind === "agent").length);
+  const instNames = generateOnoma(run.seed, "INSTITUTION", run.rows.filter((r) => r.kind === "institution").length);
+  let ai = 0, ii = 0;
+  const cast = people.map((r) => {
+    const name = r.kind === "agent" ? names[ai++]?.name ?? r.label : instNames[ii++]?.name ?? r.label;
+    return { id: r.id, label: r.label, name, kind: r.kind, live: live.has(r.id), degree: r.relations.length };
+  });
+  const byId = new Map(run.rows.map((r) => [r.id, r]));
+  const edges: RelationEdge[] = [];
+  const seen = new Set<string>();
+  for (const r of run.rows) {
+    for (const other of r.relations) {
+      const key = [r.id, other].sort().join("~");
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const o = byId.get(other);
+      if (!o) continue;
+      const bothPeople = r.kind !== "setting" && o.kind !== "setting";
+      edges.push({
+        a: r.id, b: other,
+        kind: r.kind === "strand" || o.kind === "strand" ? "strand" : bothPeople ? "peer" : "co-located",
+      });
+    }
+  }
+  return { cast, edges };
+}