2sagaco48 1.0.0

package/src/lib/sage/saga-os-v4-aureate.ts

@@ -0,0 +1,1161 @@
+/**
+ * SAGA-OS v4 — AUREATE-SCRIBE (SYSTEM v15)
+ * ---------------------------------------------------------------------------
+ * Type C net-new. Real, deterministic, offline implementations of the v4
+ * subsystems that the package (`saga-os-v4.ts`) carries only as canonical
+ * tables plus two helpers.
+ *
+ *   §4  STYLEBOOK-COMPILER   nine executable style layers (Williams, Pinker,
+ *                            Strunk, Dreyer, Booth, Le Guin, Zinsser, Clark,
+ *                            Tufte) as passes over real text
+ *   §5  STYLE-GENOME         formal genotype + genre defaults + pack overlay
+ *   §6  SENTENCE ENGINE      SentencePlan, 16 syntax forms, selection rule,
+ *                            characters-as-subjects / actions-as-verbs analyzer
+ *   §7  PARAGRAPH ENGINE     10 paragraph types, move detection, PAR-AUD-001..006
+ *   §8  IMAGECHAIN ENGINE    motif family extraction, recurrence, IMG-001..006
+ *   §9  SOUND / RHYTHM       10 sound variables, 8 rhythm profiles, RHY-AUD-001..005
+ *   §10 POV / FOCALIZATION   POV-AUD-001..005
+ *   §11 DIALOGUE ENGINE      speech acts, 11-dim idiolect vector, DIA-AUD-001..006
+ *   §12 ARGUMENT / WARRANT   passage classification, ARG-AUD-001..005
+ *   §13 REVISION STACK       PASS-001..015 executed in order over real prose
+ *   §14 KALLOS-S             12 weighted dims + 5 hard gates (fail ⇒ 0)
+ *   §15 STYLE-CGOL           style-state automaton over discourse units
+ *   §17 STYLE PACKS          7 packs as genome deltas
+ *   §19 STYLE-TEST-001..015  executable acceptance tests
+ *
+ * RUNTIME HONESTY
+ *  - Pure functions. No LLM, no network, no filesystem, no clock inside math.
+ *  - Every analyzer is LEXICAL/HEURISTIC over real English text: regex families,
+ *    closed word lists, syllable counting, positional statistics. There is NO
+ *    parser and NO semantic model here. That ceiling is declared on every report
+ *    via `method`, and STYLE-TEST rows that need a parser or a human are marked
+ *    NOT_EXECUTABLE with the concrete blocker rather than faked.
+ *  - v4 §0's own non-overclaim boundary is preserved verbatim in `V4_HONESTY`.
+ */
+
+import { computeProseMetrics } from '@/lib/sage/judge.ts';
+import { STYLE_GENOME_GENRE_DEFAULTS, selectSyntaxForm, auditWanIntensifiers } from '@/lib/sage/saga-os-v4.ts';
+import { sha256Hex, GenomeRng } from "./saga-os-v3-core";
+
+
+export const SAGA_OS_V4_AUREATE_VERSION =
+  "SAGA-OS v4 AUREATE-SCRIBE (SYSTEM v15) — STYLEBOOK-COMPILER · STYLE-GENOME · SENTENCE/PARAGRAPH/IMAGE/SOUND/POV/DIALOGUE/ARGUMENT engines · REVISION STACK · KALLOS-S · STYLE-CGOL";
+
+export const V4_HONESTY = [
+  "SAGA-OS v4 converts style into explicit, audited generative machinery, but no system can guarantee award-winning prose without implementation, corpus calibration, human evaluation, and iterative editorial testing.",
+  "Every analyzer below is lexical/heuristic. There is no syntactic parser and no semantic model in this build; a violation written in plain, well-formed words can pass an audit it should fail.",
+  "Hemingway-style readability checks are used as MINOR audits only and are explicitly prevented from flattening literary prose (v4 §18).",
+] as const;
+
+const clamp01 = (x: number) => Math.max(0, Math.min(1, x));
+const words = (t: string) => (t.trim().match(/[A-Za-z'’-]+/g) || []);
+const sentencesOf = (t: string) =>
+  (t.replace(/\s+/g, " ").match(/[^.!?]+[.!?]+(?=\s|$)|[^.!?]+$/g) || []).map((s) => s.trim()).filter((s) => s.length > 1);
+/**
+ * Discourse units. Prose paragraphs are blank-line separated, but dialogue is
+ * conventionally one speaker per LINE with no blank line between turns.
+ * Splitting only on blank lines merged whole dialogue exchanges into a single
+ * "paragraph" and hid every per-turn audit — verified defect.
+ */
+const paragraphsOf = (t: string): string[] => {
+  const out: string[] = [];
+  for (const block of t.split(/\n\s*\n/)) {
+    const lines = block.split("\n").map((l) => l.trim()).filter(Boolean);
+    if (!lines.length) continue;
+    let buf: string[] = [];
+    const flush = () => { if (buf.length) { out.push(buf.join(" ")); buf = []; } };
+    for (const line of lines) {
+      if (/^["“]/.test(line)) { flush(); out.push(line); } else buf.push(line);
+    }
+    flush();
+  }
+  return out;
+};
+function syllables(w: string): number {
+  const s = w.toLowerCase().replace(/[^a-z]/g, "");
+  if (!s) return 0;
+  const m = s.replace(/e$/, "").match(/[aeiouy]+/g);
+  return Math.max(1, m ? m.length : 1);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// §5 STYLE-GENOME
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type ProseMode =
+  | "classic" | "transparent" | "lyrical" | "spare" | "baroque"
+  | "comic" | "gothic" | "procedural" | "intimate" | "epic";
+export type FocalDistance = "close" | "medium" | "far" | "roving";
+
+export type StyleGenome = {
+  clarityLevel: number; ornamentLevel: number; sentenceMusic: number;
+  syntacticComplexity: number; concreteness: number; interiority: number;
+  compression: number; ambiguityTolerance: number; dialogueDensity: number;
+  imageDensity: number; soundDensity: number; humorDensity: number;
+  rhetoricalFormality: number; focalDistance: FocalDistance; proseMode: ProseMode;
+};
+
+export const STYLE_GENOME_KEYS: (keyof StyleGenome)[] = [
+  "clarityLevel", "ornamentLevel", "sentenceMusic", "syntacticComplexity", "concreteness",
+  "interiority", "compression", "ambiguityTolerance", "dialogueDensity", "imageDensity",
+  "soundDensity", "humorDensity", "rhetoricalFormality",
+];
+
+/** §5.1 genre defaults, read from the package table (12 numeric columns). */
+const GENRE_ROW_ORDER = [
+  "clarityLevel", "ornamentLevel", "sentenceMusic", "syntacticComplexity", "concreteness",
+  "interiority", "compression", "ambiguityTolerance", "dialogueDensity", "imageDensity",
+  "soundDensity", "rhetoricalFormality",
+] as const;
+
+const MODE_FOR_GENRE: Record<string, ProseMode> = {
+  romance: "intimate", thriller: "spare", mystery: "classic", literary: "lyrical",
+  fantasy: "epic", horror: "gothic", institutional: "procedural",
+};
+const FOCAL_FOR_GENRE: Record<string, FocalDistance> = {
+  romance: "close", thriller: "close", mystery: "medium", literary: "close",
+  fantasy: "roving", horror: "close", institutional: "far",
+};
+
+/** Map a v3 GenreContract family/key onto the v4 genre-default rows. */
+export function genreDefaultKey(genreKey: string, family?: string): string {
+  const k = genreKey.toLowerCase();
+  if (STYLE_GENOME_GENRE_DEFAULTS[k]) return k;
+  if (/thriller/.test(k)) return "thriller";
+  if (/mystery|cozy|procedural/.test(k)) return "mystery";
+  if (/horror/.test(k)) return "horror";
+  if (/romantasy|fantasy/.test(k)) return "fantasy";
+  if (/romance/.test(k)) return "romance";
+  if (/institutional|maintenance/.test(k)) return "institutional";
+  if (/literary|general|historical|family|saga|ya|comedy|science/.test(k)) return "literary";
+  const f = (family ?? "").toUpperCase();
+  if (f === "THRILLER") return "thriller";
+  if (f === "MYSTERY") return "mystery";
+  if (f === "HORROR") return "horror";
+  if (f === "FANTASY") return "fantasy";
+  if (f === "ROMANCE") return "romance";
+  return "literary";
+}
+
+export function buildStyleGenome(genreKey: string, family?: string, overrides?: Partial<StyleGenome>): StyleGenome {
+  const key = genreDefaultKey(genreKey, family);
+  const row = STYLE_GENOME_GENRE_DEFAULTS[key] ?? STYLE_GENOME_GENRE_DEFAULTS.literary;
+  const g = {} as StyleGenome;
+  GENRE_ROW_ORDER.forEach((field, i) => { (g as unknown as Record<string, number>)[field] = row[i] ?? 0.5; });
+  g.humorDensity = key === "literary" ? 0.25 : key === "romance" ? 0.35 : 0.15;
+  g.proseMode = MODE_FOR_GENRE[key] ?? "classic";
+  g.focalDistance = FOCAL_FOR_GENRE[key] ?? "medium";
+  return { ...g, ...overrides };
+}
+
+// §17 production style packs — deltas applied on top of the genre genome
+export type StylePackId =
+  | "STYLEPACK-SPARE" | "STYLEPACK-CLASSIC" | "STYLEPACK-GRACE" | "STYLEPACK-LYRICAL"
+  | "STYLEPACK-COPYCHIEF" | "STYLEPACK-ARGUMENT" | "STYLEPACK-POPULAR";
+
+export const STYLE_PACK_DELTAS: Record<StylePackId, { note: string; delta: Partial<StyleGenome> }> = {
+  "STYLEPACK-SPARE": { note: "Strunk/Zinsser-heavy: high compression, low ornament, high concreteness", delta: { compression: 0.9, ornamentLevel: 0.12, concreteness: 0.9, syntacticComplexity: 0.28, proseMode: "spare" } },
+  "STYLEPACK-CLASSIC": { note: "Pinker/Williams-heavy: reader gaze, clear syntax, topic-stress", delta: { clarityLevel: 0.92, ornamentLevel: 0.3, syntacticComplexity: 0.45, proseMode: "classic" } },
+  "STYLEPACK-GRACE": { note: "Williams/Tufte-heavy: balanced syntax, emphatic endings, cadence", delta: { clarityLevel: 0.85, sentenceMusic: 0.72, syntacticComplexity: 0.6, ornamentLevel: 0.45, proseMode: "classic" } },
+  "STYLEPACK-LYRICAL": { note: "Le Guin/Tufte-heavy: sound, image, long curves, omission", delta: { sentenceMusic: 0.88, imageDensity: 0.85, soundDensity: 0.85, syntacticComplexity: 0.75, compression: 0.35, proseMode: "lyrical" } },
+  "STYLEPACK-COPYCHIEF": { note: "Dreyer-heavy: grammar hygiene, house style, punctuation judgment", delta: { clarityLevel: 0.9, ornamentLevel: 0.25, compression: 0.7, rhetoricalFormality: 0.6, proseMode: "transparent" } },
+  "STYLEPACK-ARGUMENT": { note: "Booth-heavy: claim-reason-evidence-warrant passages", delta: { clarityLevel: 0.9, rhetoricalFormality: 0.7, interiority: 0.7, ambiguityTolerance: 0.25, proseMode: "classic" } },
+  "STYLEPACK-POPULAR": { note: "Clark/Zinsser/Pinker hybrid: subject/verb drive, pattern/twist, low clutter", delta: { clarityLevel: 0.88, compression: 0.75, ornamentLevel: 0.28, dialogueDensity: 0.7, proseMode: "transparent" } },
+};
+
+export function applyStylePack(g: StyleGenome, pack: StylePackId | null): StyleGenome {
+  return pack ? { ...g, ...STYLE_PACK_DELTAS[pack].delta } : g;
+}
+
+export const STYLE_PACK_KEY = "veritas.saga.stylePack.v1";
+export function loadStylePack(): StylePackId | null {
+  try { const v = localStorage.getItem(STYLE_PACK_KEY); return v && v in STYLE_PACK_DELTAS ? (v as StylePackId) : null; } catch { return null; }
+}
+export function saveStylePack(p: StylePackId | null): void {
+  try { if (p) localStorage.setItem(STYLE_PACK_KEY, p); else localStorage.removeItem(STYLE_PACK_KEY); } catch { /* optional */ }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Shared lexicons (closed lists — the declared ceiling of this build)
+// ═══════════════════════════════════════════════════════════════════════════
+
+const NOMINALIZATION_RE = /\b[a-z]{3,}(?:tion|sion|ment|ance|ence|ity|ness|ing)\b/gi;
+const BE_VERBS = /\b(is|are|was|were|be|been|being|am)\b/gi;
+/**
+ * Williams' central diagnosis is not "a be-verb plus a noun" — it is that the
+ * real ACTION has been buried in a nominalization while the verb slot is filled
+ * by an empty one. Light/support verbs ("made a determination", "gave
+ * consideration to", "took an examination") are the canonical case and were
+ * previously invisible to the detector: `beVerbCount` was 0, so
+ * `actionIsVerb` returned true for prose that is exactly what Style warns
+ * against. Verified by adversarial attack A1.
+ */
+const LIGHT_VERB_NOM_RE = /\b(?:make|makes|made|making|give|gives|gave|given|giving|take|takes|took|taken|taking|have|has|had|having|do|does|did|doing|perform|performs|performed|conduct|conducts|conducted|undertake|undertakes|undertook|undertaken|provide|provides|provided|carry\s+out|carries\s+out|carried\s+out|reach|reaches|reached)\s+(?:a|an|the|some|any|no)?\s*[a-z]{3,}(?:tion|sion|ment|ance|ence|ity|ness|al|ing)\b/gi;
+const PASSIVE_RE = /\b(is|are|was|were|be|been|being)\s+(\w+(?:ed|en))\b/gi;
+const ADVERB_LY_RE = /\b\w{4,}ly\b/gi;
+const HEDGE_RE = /\b(somewhat|rather|quite|fairly|perhaps|maybe|possibly|arguably|seemingly|apparently|sort of|kind of)\b/gi;
+const CLUTTER_RE = /\b(in order to|due to the fact that|at this point in time|the fact that|in terms of|for all intents and purposes|it should be noted that|there (?:is|are|was|were)\b)/gi;
+const CONCRETE_SENSE_RE = /\b(salt|ash|iron|rust|dust|smoke|glass|stone|wood|cloth|paper|water|rain|mud|blood|bone|skin|hair|bread|oil|wire|nail|rope|thread|coal|clay|wool|leather|brick|frost|grease|copper|tin|silt|lime|straw|hay|sand|resin|tar|chalk|wax|soot|grain|milk|honey|vinegar)\b/gi;
+const ABSTRACT_RE = /\b(freedom|justice|beauty|truth|reality|society|existence|meaning|purpose|identity|concept|notion|aspect|situation|condition|process|system|structure|element|factor|issue|matter)\b/gi;
+const CLICHE_LIST = [
+  "at the end of the day", "avoid like the plague", "back to square one", "beat around the bush",
+  "better late than never", "bite the bullet", "blessing in disguise", "break the ice",
+  "calm before the storm", "cat got your tongue", "cold as ice", "cry over spilled milk",
+  "dead as a doornail", "diamond in the rough", "easier said than done", "every cloud has a silver lining",
+  "few and far between", "fit as a fiddle", "give it your all", "heart of gold",
+  "in the nick of time", "last but not least", "leave no stone unturned", "light as a feather",
+  "needle in a haystack", "nip it in the bud", "only time will tell", "pale as a ghost",
+  "piece of cake", "quiet as a mouse", "read between the lines", "silence was deafening",
+  "sea of faces", "sharp as a tack", "sight for sore eyes", "time heals all wounds",
+  "tip of the iceberg", "under the weather", "white as a sheet", "world at your feet",
+  "heart skipped a beat", "blood ran cold", "breath caught in", "let out a breath she didn't know",
+  "little did", "eyes widened", "shiver down", "deafening silence",
+];
+const SPEECH_ACT_LEX: [RegExp, string][] = [
+  [/\?\s*["'”’]?\s*$/, "QUESTION"],
+  [/\b(please|would you|could you|will you|can you)\b/i, "REQUEST"],
+  [/\b(don't|do not|stop|never|no\.|get out|leave)\b/i, "PROHIBIT"],
+  [/\b(i (?:promise|swear|will)|we will)\b/i, "COMMIT"],
+  [/\b(sorry|apolog|forgive)\b/i, "APOLOGISE"],
+  [/\b(you (?:always|never)|your fault|because of you)\b/i, "ACCUSE"],
+  [/\b(i think|i believe|i suppose|maybe|perhaps)\b/i, "HEDGE"],
+  [/!\s*["'”’]?\s*$/, "EXCLAIM"],
+];
+const ARG_CLAIM_RE = /\b(therefore|thus|so it (?:is|was)|which means|the point is|that is why|it follows)\b/i;
+const ARG_REASON_RE = /\b(because|since|as a result of|owing to|given that|for this reason)\b/i;
+const ARG_EVIDENCE_RE = /\b(\d|the ledger|the record|the letter|she saw|he saw|the report|the form|the invoice|showed|proved|witness)\b/i;
+const ARG_QUALIFY_RE = /\b(unless|except|although|though|admittedly|granted|but only if)\b/i;
+const FUTURE_LEAK_RE = /\b(later (?:she|he|they) would|would (?:soon )?(?:learn|discover|realise|realize)|years later|little did (?:she|he|they) know|would come to)\b/i;
+const EMOTION_LABEL_RE = /\b(felt (?:sad|angry|happy|afraid|guilty|ashamed)|was (?:sad|angry|happy|afraid|guilty|ashamed)|felt an? \w+)\b/gi;
+const FIGURATIVE_RE = /\b(like a|like the|as if|as though|resembl\w+|reminded \w+ of)\b/gi;
+
+// ═══════════════════════════════════════════════════════════════════════════
+// §6 SENTENCE ENGINE — plans + real analysis of finished sentences
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type SyntaxFormId =
+  | "SYN-001" | "SYN-002" | "SYN-003" | "SYN-004" | "SYN-005" | "SYN-006" | "SYN-007" | "SYN-008"
+  | "SYN-009" | "SYN-010" | "SYN-011" | "SYN-012" | "SYN-013" | "SYN-014" | "SYN-015" | "SYN-016";
+
+export const SYNTAX_FORM_NAMES: Record<SyntaxFormId, string> = {
+  "SYN-001": "Kernel sentence", "SYN-002": "Cumulative sentence", "SYN-003": "Periodic sentence",
+  "SYN-004": "Balanced sentence", "SYN-005": "Antithetical sentence", "SYN-006": "Appositive expansion",
+  "SYN-007": "Parallel triad", "SYN-008": "Fragment with prior license", "SYN-009": "Question sentence",
+  "SYN-010": "Negative sentence", "SYN-011": "Inverted sentence", "SYN-012": "Dialogue beat sentence",
+  "SYN-013": "Image sentence", "SYN-014": "Procedural sentence", "SYN-015": "Lyrical long sentence",
+  "SYN-016": "Hard stop sentence",
+};
+
+export type RhythmClass = "short" | "medium" | "long" | "very-long";
+
+export type SentenceAnalysis = {
+  index: number;
+  text: string;
+  wordCount: number;
+  rhythmClass: RhythmClass;
+  syntaxForm: SyntaxFormId;
+  /** Williams: is the first noun phrase also the actor? (heuristic) */
+  subjectIsCharacter: boolean;
+  /** Williams: is the main action a finite verb rather than a nominalization? */
+  actionIsVerb: boolean;
+  nominalizations: string[];
+  /** Williams: an empty light/support verb carrying the real action as a noun. */
+  lightVerbNominalization: boolean;
+  passive: boolean;
+  beVerbCount: number;
+  /** old→new: does the opening overlap with the previous sentence's tail? */
+  oldBeforeNew: boolean | null;
+  /** stress: does it end on content rather than a function-word tail? */
+  emphaticEnd: boolean;
+  clutterHits: string[];
+  hedges: string[];
+  adverbs: string[];
+  concreteHits: string[];
+  abstractHits: string[];
+  figurative: number;
+  isDialogue: boolean;
+  syllablesPerWord: number;
+};
+
+const FUNCTION_TAIL = new Set(["the", "a", "an", "of", "to", "in", "on", "at", "for", "with", "and", "or", "but", "that", "it", "is", "was", "as", "by", "from", "this", "there", "been", "very", "too", "so"]);
+const PRONOUN_SUBJ = new Set(["he", "she", "they", "i", "we", "you", "it"]);
+
+function detectSyntaxForm(s: string, w: string[], prior: SentenceAnalysis | null): SyntaxFormId {
+  const t = s.trim();
+  if (/^["'“]/.test(t) || /["'”]\s*$/.test(t)) return "SYN-012";
+  if (/\?$/.test(t)) return "SYN-009";
+  if (w.length <= 4 && !/[.!?]$/.test(t)) return "SYN-008";
+  if (w.length <= 5) return "SYN-016";
+  if (/\bnot\b|\bnever\b|\bno\b/i.test(t) && w.length < 20) return "SYN-010";
+  if (/,\s*(?:a|an|the)\s+[a-z]+[^,]*,/i.test(t)) return "SYN-006";
+  if (/\b\w+,\s*\w+,\s*and\s+\w+/i.test(t)) return "SYN-007";
+  if (/\bbut\b|\byet\b|\bwhereas\b|\bwhile\b/i.test(t) && /,/.test(t)) return "SYN-005";
+  if (/^(?:Not|Never|Only|Down|Up|Into|Across|Behind|Beneath)\b/.test(t)) return "SYN-011";
+  if (/^[A-Z][a-z]*(?:ing|ed)\b|^(?:After|Before|When|Because|Although|Since|If)\b/.test(t) && w.length > 14) return "SYN-003";
+  if (w.length > 32) return "SYN-015";
+  if (/,\s*\w+ing\b/.test(t)) return "SYN-002";
+  if (FIGURATIVE_RE.test(t)) { FIGURATIVE_RE.lastIndex = 0; return "SYN-013"; }
+  if (/\b(then|next|first|second|after that|meanwhile)\b/i.test(t)) return "SYN-014";
+  if (/;|\bboth\b.*\band\b/.test(t) && w.length > 12) return "SYN-004";
+  return prior?.syntaxForm === "SYN-001" && w.length > 18 ? "SYN-002" : "SYN-001";
+}
+
+export function analyzeSentences(text: string): SentenceAnalysis[] {
+  const out: SentenceAnalysis[] = [];
+  const sents = sentencesOf(text);
+  for (let i = 0; i < sents.length; i++) {
+    const s = sents[i];
+    const w = words(s);
+    const lower = s.toLowerCase();
+    const prior = out[i - 1] ?? null;
+    const firstWords = w.slice(0, 4).map((x) => x.toLowerCase());
+    // Williams: the sentence's main character should BE the grammatical subject.
+    // A capital letter is not evidence of that — "There was a realization…" and
+    // "The implementation of…" both opened with a capital and were scored as
+    // character-subjects (verified defect). Reject expletive openings and
+    // openings whose head noun is an abstraction/nominalization.
+    const bare = s.replace(/^["'“]\s*/, "");
+    const headMatch = /^(?:The|A|An)\s+([A-Za-z-]+)/i.exec(bare);
+    const headNoun = (headMatch?.[1] ?? "").toLowerCase();
+    const expletive = /^(?:there|it)\s+(?:is|are|was|were|has|have|had|seems|appears)\b/i.test(bare);
+    const headIsAbstract = !!headNoun && (NOMINALIZATION_RE.test(headNoun) || ABSTRACT_RE.test(headNoun));
+    NOMINALIZATION_RE.lastIndex = 0; ABSTRACT_RE.lastIndex = 0;
+    const properOpen = /^[A-Z][a-z]+\b/.test(bare) && !/^(?:The|A|An|There|It|This|That|These|Those)\b/.test(bare);
+    const subjectIsCharacter =
+      !expletive && !headIsAbstract &&
+      (firstWords.some((x) => PRONOUN_SUBJ.has(x)) || properOpen || (!!headNoun && !headIsAbstract));
+    const noms = s.match(NOMINALIZATION_RE) ?? [];
+    const realNoms = noms.filter((n) => !/^(?:something|nothing|morning|evening|during|building|ceiling|meeting)$/i.test(n));
+    const beCount = (s.match(BE_VERBS) ?? []).length;
+    const passive = PASSIVE_RE.test(s); PASSIVE_RE.lastIndex = 0;
+    LIGHT_VERB_NOM_RE.lastIndex = 0;
+    const lightVerbNom = LIGHT_VERB_NOM_RE.test(s);
+    LIGHT_VERB_NOM_RE.lastIndex = 0;
+    // The action is a real finite verb only if it is NOT buried behind a
+    // be-verb + nominalization, NOT buried behind a light/support verb +
+    // nominalization, and NOT passivised.
+    const actionIsVerb = !(beCount > 0 && realNoms.length > 0) && !lightVerbNom && !passive;
+    let oldBeforeNew: boolean | null = null;
+    if (prior) {
+      const priorTail = new Set(words(prior.text).slice(-6).map((x) => x.toLowerCase()));
+      const head = w.slice(0, 5).map((x) => x.toLowerCase());
+      oldBeforeNew = head.some((x) => priorTail.has(x) || PRONOUN_SUBJ.has(x));
+    }
+    const lastWord = (w[w.length - 1] ?? "").toLowerCase();
+    const emphaticEnd = !FUNCTION_TAIL.has(lastWord) && lastWord.length > 2;
+    const clutterHits = s.match(CLUTTER_RE) ?? [];
+    const hedges = s.match(HEDGE_RE) ?? [];
+    const adverbs = s.match(ADVERB_LY_RE) ?? [];
+    const concreteHits = s.match(CONCRETE_SENSE_RE) ?? [];
+    const abstractHits = s.match(ABSTRACT_RE) ?? [];
+    const fig = (s.match(FIGURATIVE_RE) ?? []).length;
+    const rhythmClass: RhythmClass = w.length <= 8 ? "short" : w.length <= 18 ? "medium" : w.length <= 32 ? "long" : "very-long";
+    out.push({
+      index: i, text: s, wordCount: w.length, rhythmClass,
+      syntaxForm: detectSyntaxForm(s, w, prior),
+      subjectIsCharacter, actionIsVerb, nominalizations: realNoms, lightVerbNominalization: lightVerbNom, passive, beVerbCount: beCount,
+      oldBeforeNew, emphaticEnd, clutterHits, hedges, adverbs, concreteHits, abstractHits,
+      figurative: fig, isDialogue: /^["'“]/.test(s.trim()),
+      syllablesPerWord: w.length ? w.reduce((a, x) => a + syllables(x), 0) / w.length : 0,
+    });
+    void lower;
+  }
+  return out;
+}
+
+/** §6.1 SentencePlan — the generative side (used by the planner UI + directive). */
+export type SentencePlan = {
+  index: number;
+  mainCharacter: string; grammaticalSubject: string;
+  mainAction: string; finiteVerb: string;
+  oldInformation: string; newInformation: string;
+  topicPosition: string; stressPosition: string;
+  image?: string; soundPattern?: string;
+  rhythmClass: RhythmClass; syntaxForm: SyntaxFormId;
+  register: string; povDistance: FocalDistance;
+  warrantRole?: "CLAIM" | "REASON" | "EVIDENCE" | "WARRANT" | null;
+};
+
+/** §6.3 selection rule — delegates to the package selector, then records the plan. */
+export function planSentences(x: {
+  seedHex: string; count: number; genome: StyleGenome;
+  sceneForce: "clarity" | "emotional" | "lyrical" | "argument" | "neutral";
+  character: string; action: string; oldInfo: string; newInfo: string;
+  image?: string;
+}): SentencePlan[] {
+  const rng = new GenomeRng(sha256Hex(`aureate|plan|${x.seedHex}|${x.sceneForce}`));
+  const prior: string[] = [];
+  const plans: SentencePlan[] = [];
+  for (let i = 0; i < x.count; i++) {
+    const form = selectSyntaxForm({
+      clarityRequired: x.sceneForce === "clarity",
+      emotionalPeak: x.sceneForce === "emotional",
+      lyricalMode: x.sceneForce === "lyrical",
+      argumentMode: x.sceneForce === "argument",
+    }, prior as never[]) as SyntaxFormId;
+    prior.push(form);
+    const long = form === "SYN-015" || form === "SYN-002" || form === "SYN-003";
+    const shortF = form === "SYN-016" || form === "SYN-008";
+    plans.push({
+      index: i,
+      mainCharacter: x.character, grammaticalSubject: x.character,
+      mainAction: x.action, finiteVerb: x.action.split(/\s+/)[0] ?? x.action,
+      oldInformation: i === 0 ? x.oldInfo : x.newInfo,
+      newInformation: x.newInfo,
+      topicPosition: i === 0 ? x.oldInfo : x.newInfo,
+      stressPosition: x.newInfo,
+      image: x.image && rng.next() < x.genome.imageDensity ? x.image : undefined,
+      soundPattern: rng.next() < x.genome.soundDensity ? (rng.next() < 0.5 ? "liquid" : "plosive") : undefined,
+      rhythmClass: shortF ? "short" : long ? "long" : "medium",
+      syntaxForm: form,
+      register: x.genome.rhetoricalFormality > 0.5 ? "formal" : "plain",
+      povDistance: x.genome.focalDistance,
+      warrantRole: x.sceneForce === "argument" ? (i === 0 ? "CLAIM" : i === 1 ? "REASON" : i === 2 ? "EVIDENCE" : "WARRANT") : null,
+    });
+  }
+  return plans;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// §7 PARAGRAPH ENGINE
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type ParagraphTypeId =
+  | "PAR-001" | "PAR-002" | "PAR-003" | "PAR-004" | "PAR-005"
+  | "PAR-006" | "PAR-007" | "PAR-008" | "PAR-009" | "PAR-010";
+export const PARAGRAPH_TYPE_NAMES: Record<ParagraphTypeId, string> = {
+  "PAR-001": "Action", "PAR-002": "Sensory", "PAR-003": "Interior-processing", "PAR-004": "Argument / reflection",
+  "PAR-005": "Dialogue", "PAR-006": "Institutional", "PAR-007": "Transition", "PAR-008": "Ritual",
+  "PAR-009": "Memory", "PAR-010": "Shock",
+};
+
+export type ParagraphAnalysis = {
+  index: number; text: string; type: ParagraphTypeId;
+  sentences: SentenceAnalysis[];
+  hasAnchor: boolean; oldNewChainRatio: number; finalSentenceStress: boolean;
+  abstractionAnchored: boolean; lengthSentences: number;
+  move: { anchor: string; development: string; turn: string; stress: string };
+};
+
+function classifyParagraph(p: string, sents: SentenceAnalysis[]): ParagraphTypeId {
+  const dial = sents.filter((s) => s.isDialogue).length / Math.max(1, sents.length);
+  if (dial >= 0.4) return "PAR-005";
+  if (/\b(remember|remembered|years ago|when (?:she|he|they) was|used to)\b/i.test(p)) return "PAR-009";
+  if (/\b(office|registry|form|permit|ruling|committee|clerk|statute|ordinance|court)\b/i.test(p)) return "PAR-006";
+  if (/\b(rite|ritual|ceremony|procession|liturgy|vigil|oath)\b/i.test(p)) return "PAR-008";
+  if (sents.length <= 2 && sents.some((s) => s.wordCount <= 8)) return "PAR-010";
+  if (ARG_CLAIM_RE.test(p) || ARG_REASON_RE.test(p)) return "PAR-004";
+  if (/\b(thought|wondered|considered|decided|knew|realised|realized|wanted)\b/i.test(p)) return "PAR-003";
+  if ((p.match(CONCRETE_SENSE_RE) ?? []).length >= 2) return "PAR-002";
+  if (/\b(walked|ran|opened|closed|lifted|pushed|pulled|crossed|struck|carried)\b/i.test(p)) return "PAR-001";
+  return "PAR-007";
+}
+
+export function analyzeParagraphs(text: string): ParagraphAnalysis[] {
+  return paragraphsOf(text).map((p, i) => {
+    const sents = analyzeSentences(p);
+    const chain = sents.slice(1);
+    const oldNew = chain.length ? chain.filter((s) => s.oldBeforeNew).length / chain.length : 1;
+    const last = sents[sents.length - 1];
+    const abstractCount = sents.reduce((a, s) => a + s.abstractHits.length, 0);
+    const concreteCount = sents.reduce((a, s) => a + s.concreteHits.length, 0);
+    return {
+      index: i, text: p, type: classifyParagraph(p, sents), sentences: sents,
+      hasAnchor: !!sents[0] && (sents[0].subjectIsCharacter || sents[0].concreteHits.length > 0),
+      oldNewChainRatio: oldNew,
+      finalSentenceStress: !!last?.emphaticEnd,
+      abstractionAnchored: abstractCount === 0 || concreteCount >= 1,
+      lengthSentences: sents.length,
+      move: {
+        anchor: sents[0]?.text.slice(0, 60) ?? "",
+        development: sents[1]?.text.slice(0, 60) ?? "",
+        turn: sents.length > 2 ? sents[Math.floor(sents.length / 2)].text.slice(0, 60) : "",
+        stress: last?.text.slice(-60) ?? "",
+      },
+    };
+  });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// §8 IMAGECHAIN ENGINE
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type ImageFamily = {
+  motifId: string; sourceDomain: string; sensoryChannel: string;
+  occurrences: { paragraph: number; sentence: number; context: string }[];
+  contextsDiffer: boolean; transformed: boolean;
+};
+
+const IMAGE_DOMAINS: [string, RegExp, string][] = [
+  ["water", /\b(water|river|tide|rain|flood|current|salt|wave|damp|drip|well)\w*\b/gi, "touch/sight"],
+  ["fire", /\b(fire|flame|ember|ash|smoke|burn|scorch|coal|soot)\w*\b/gi, "sight/smell"],
+  ["metal", /\b(iron|steel|copper|tin|rust|nail|wire|blade|hinge|chain)\w*\b/gi, "touch/sound"],
+  ["cloth", /\b(cloth|thread|wool|linen|seam|hem|stitch|weave|coat)\w*\b/gi, "touch"],
+  ["stone", /\b(stone|brick|gravel|slate|granite|wall|floor|step)\w*\b/gi, "touch/sight"],
+  ["light", /\b(light|shadow|glare|dusk|dawn|lamp|glint|dark)\w*\b/gi, "sight"],
+  ["bone", /\b(bone|skull|rib|spine|tooth|marrow)\w*\b/gi, "touch"],
+  ["paper", /\b(paper|ledger|page|ink|letter|receipt|form|record)\w*\b/gi, "sight/touch"],
+  ["plant", /\b(root|leaf|branch|seed|grain|straw|hay|moss|vine)\w*\b/gi, "sight/smell"],
+  ["sound", /\b(hum|creak|echo|silence|bell|knock|scrape|whistle)\w*\b/gi, "hearing"],
+];
+
+export function extractImageChains(text: string): ImageFamily[] {
+  const paras = paragraphsOf(text);
+  const out: ImageFamily[] = [];
+  for (const [domain, re, channel] of IMAGE_DOMAINS) {
+    const occ: ImageFamily["occurrences"] = [];
+    paras.forEach((p, pi) => {
+      const sents = sentencesOf(p);
+      sents.forEach((s, si) => {
+        re.lastIndex = 0;
+        // count EVERY hit in the sentence, not just the first: "the gate stuck"
+        // and "the iron" in one sentence are two occurrences of the metal family.
+        const hits = s.match(re);
+        if (hits) for (let h = 0; h < hits.length; h++) occ.push({ paragraph: pi, sentence: si, context: s.slice(0, 90) });
+      });
+    });
+    if (occ.length === 0) continue;
+    // Compare DISTINCT host sentences. Multiple hits inside one sentence share
+    // the same context string, so comparing raw occurrences made every family
+    // look un-transformed (verified defect). IMG-002 is about the motif
+    // returning in a changed context, which is a between-sentence property.
+    const seenCtx = new Set<string>();
+    const distinctCtx: string[] = [];
+    for (const o of occ) {
+      const key = `${o.paragraph}:${o.sentence}`;
+      if (seenCtx.has(key)) continue;
+      seenCtx.add(key); distinctCtx.push(o.context);
+    }
+    const ctxWords = distinctCtx.map((c) => new Set(words(c).map((w) => w.toLowerCase())));
+    let differ = ctxWords.length >= 2;
+    for (let i = 1; i < ctxWords.length; i++) {
+      const a = ctxWords[i - 1], b = ctxWords[i];
+      const inter = [...b].filter((w) => a.has(w)).length;
+      const jaccard = inter / Math.max(1, new Set([...a, ...b]).size);
+      if (jaccard > 0.6) { differ = false; break; }
+    }
+    out.push({
+      motifId: `IMG-${domain.toUpperCase()}`, sourceDomain: domain, sensoryChannel: channel,
+      occurrences: occ, contextsDiffer: differ,
+      // recurrence is measured in DISTINCT host sentences, not raw hits
+      transformed: distinctCtx.length >= 2 && differ,
+    });
+  }
+  return out.sort((a, b) => b.occurrences.length - a.occurrences.length);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// §9 SOUND AND RHYTHM ENGINE
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type SoundVariables = {
+  assonance: number; consonance: number; alliteration: number; sibilance: number;
+  plosiveDensity: number; liquidDensity: number; vowelOpenness: number;
+  sentenceCadence: number; stressPattern: number; pausePattern: number;
+};
+export type RhythmProfileId = "RHY-001" | "RHY-002" | "RHY-003" | "RHY-004" | "RHY-005" | "RHY-006" | "RHY-007" | "RHY-008";
+export const RHYTHM_PROFILE_NAMES: Record<RhythmProfileId, string> = {
+  "RHY-001": "Spare pulse", "RHY-002": "Procedural cadence", "RHY-003": "Lyrical wave", "RHY-004": "Comic snap",
+  "RHY-005": "Gothic accumulation", "RHY-006": "Epic roll", "RHY-007": "Domestic murmur", "RHY-008": "Thriller chop",
+};
+
+export function computeSoundVariables(text: string): SoundVariables {
+  const w = words(text);
+  const n = Math.max(1, w.length);
+  const letters = text.toLowerCase().replace(/[^a-z]/g, "");
+  const L = Math.max(1, letters.length);
+  const count = (re: RegExp) => (letters.match(re) ?? []).length;
+  const vowels = letters.match(/[aeiou]/g) ?? [];
+  const open = vowels.filter((v) => "aeo".includes(v)).length;
+  let allit = 0;
+  for (let i = 1; i < w.length; i++) if (w[i][0]?.toLowerCase() === w[i - 1][0]?.toLowerCase()) allit++;
+  const vowelPairs = new Map<string, number>();
+  for (const x of w) { const v = (x.toLowerCase().match(/[aeiou]+/) ?? [""])[0]; if (v) vowelPairs.set(v, (vowelPairs.get(v) ?? 0) + 1); }
+  const assonance = [...vowelPairs.values()].filter((c) => c > 1).reduce((a, b) => a + b, 0) / n;
+  const endings = new Map<string, number>();
+  for (const x of w) { const e = x.toLowerCase().slice(-2); if (e.length === 2) endings.set(e, (endings.get(e) ?? 0) + 1); }
+  const consonance = [...endings.values()].filter((c) => c > 1).reduce((a, b) => a + b, 0) / n;
+  const sents = sentencesOf(text);
+  const lens = sents.map((s) => words(s).length);
+  const mean = lens.length ? lens.reduce((a, b) => a + b, 0) / lens.length : 0;
+  const sd = lens.length ? Math.sqrt(lens.reduce((a, x) => a + (x - mean) ** 2, 0) / lens.length) : 0;
+  const commas = (text.match(/[,;:—–]/g) ?? []).length;
+  return {
+    assonance: clamp01(assonance), consonance: clamp01(consonance),
+    alliteration: clamp01(allit / n * 4), sibilance: clamp01(count(/s|z|sh/g) / L * 6),
+    plosiveDensity: clamp01(count(/[pbtdkg]/g) / L * 4), liquidDensity: clamp01(count(/[lrmn]/g) / L * 3),
+    vowelOpenness: clamp01(open / Math.max(1, vowels.length)),
+    sentenceCadence: clamp01(mean / 30), stressPattern: clamp01(sd / 12),
+    pausePattern: clamp01(commas / Math.max(1, sents.length) / 3),
+  };
+}
+
+export function detectRhythmProfile(sv: SoundVariables, sents: SentenceAnalysis[]): RhythmProfileId {
+  const mean = sents.length ? sents.reduce((a, s) => a + s.wordCount, 0) / sents.length : 0;
+  const shortShare = sents.filter((s) => s.rhythmClass === "short").length / Math.max(1, sents.length);
+  if (mean < 10 && shortShare > 0.5) return sv.plosiveDensity > 0.5 ? "RHY-008" : "RHY-001";
+  if (mean > 28) return sv.liquidDensity > 0.5 ? "RHY-003" : "RHY-006";
+  if (sv.pausePattern > 0.6 && mean > 20) return "RHY-005";
+  if (shortShare > 0.35 && sv.plosiveDensity > 0.45) return "RHY-004";
+  if (/\b(then|next|first|after)\b/i.test(sents.map((s) => s.text).join(" "))) return "RHY-002";
+  return "RHY-007";
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// §11 DIALOGUE ENGINE
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type IdiolectVector = {
+  sentenceLength: number; contractionRate: number; formality: number; directness: number;
+  figurativeLanguage: number; questionRate: number; interruptionRate: number; hedging: number;
+  emotionalNaming: number; specialVocabulary: number; silenceTendency: number;
+};
+export type DialogueTurnAnalysis = {
+  index: number; speaker: string | null; line: string;
+  speechAct: string; hasSubtext: boolean; wordCount: number;
+};
+
+const CONTRACTION_RE = /\b\w+['’](?:t|s|re|ve|ll|d|m)\b/gi;
+const FORMAL_RE = /\b(shall|whom|thus|hence|indeed|moreover|therefore|regarding|pursuant)\b/gi;
+
+export function extractDialogue(text: string): DialogueTurnAnalysis[] {
+  const out: DialogueTurnAnalysis[] = [];
+  const re = /["“]([^"”]{2,})["”]\s*(?:,?\s*(?:said|asked|replied|answered|murmured|snapped|whispered)\s+([A-Z][a-z]+))?/g;
+  let m: RegExpExecArray | null; let i = 0;
+  while ((m = re.exec(text)) !== null) {
+    const line = m[1].trim();
+    const speaker = m[2] ?? null;
+    let act = "ASSERT";
+    for (const [rx, name] of SPEECH_ACT_LEX) { if (rx.test(line)) { act = name; break; } }
+    const hasSubtext = /\b(nothing|fine|it's fine|whatever|if you say so|of course)\b/i.test(line) ||
+      (act === "ASSERT" && /\?/.test(line)) || /\.\.\./.test(line);
+    out.push({ index: i++, speaker, line, speechAct: act, hasSubtext, wordCount: words(line).length });
+  }
+  return out;
+}
+
+export function idiolectVector(lines: string[]): IdiolectVector {
+  const all = lines.join(" ");
+  const w = words(all); const n = Math.max(1, w.length);
+  const sents = Math.max(1, lines.length);
+  return {
+    sentenceLength: clamp01(n / sents / 25),
+    contractionRate: clamp01((all.match(CONTRACTION_RE) ?? []).length / n * 10),
+    formality: clamp01((all.match(FORMAL_RE) ?? []).length / n * 20),
+    directness: clamp01(1 - (all.match(HEDGE_RE) ?? []).length / n * 12),
+    figurativeLanguage: clamp01((all.match(FIGURATIVE_RE) ?? []).length / sents),
+    questionRate: clamp01(lines.filter((l) => /\?/.test(l)).length / sents),
+    interruptionRate: clamp01(lines.filter((l) => /[—–]\s*$|\.\.\.$/.test(l)).length / sents),
+    hedging: clamp01((all.match(HEDGE_RE) ?? []).length / n * 12),
+    emotionalNaming: clamp01((all.match(EMOTION_LABEL_RE) ?? []).length / sents),
+    specialVocabulary: clamp01(new Set(w.map((x) => x.toLowerCase())).size / n),
+    silenceTendency: clamp01(lines.filter((l) => words(l).length <= 3).length / sents),
+  };
+}
+
+export function idiolectDistance(a: IdiolectVector, b: IdiolectVector): number {
+  const ks = Object.keys(a) as (keyof IdiolectVector)[];
+  return Math.sqrt(ks.reduce((s, k) => s + (a[k] - b[k]) ** 2, 0) / ks.length);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// §12 ARGUMENT / WARRANT ENGINE
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type PassageClass = "ARGUMENTATIVE" | "LYRICAL" | "PERCEPTUAL" | "EMOTIONAL" | "PROCEDURAL";
+export type ArgumentUnit = {
+  paragraph: number; passageClass: PassageClass;
+  claim: string | null; reason: string | null; evidence: string | null;
+  warrantExplicit: boolean; qualification: string | null; complete: boolean;
+};
+
+export function classifyPassage(p: ParagraphAnalysis): PassageClass {
+  if (p.type === "PAR-004" || ARG_CLAIM_RE.test(p.text)) return "ARGUMENTATIVE";
+  if (p.type === "PAR-006" || p.type === "PAR-001" || /\b(then|next|first|after that)\b/i.test(p.text)) return "PROCEDURAL";
+  if (p.sentences.reduce((a, s) => a + s.figurative, 0) >= 2) return "LYRICAL";
+  if (p.type === "PAR-002") return "PERCEPTUAL";
+  if (p.type === "PAR-003" || EMOTION_LABEL_RE.test(p.text)) { EMOTION_LABEL_RE.lastIndex = 0; return "EMOTIONAL"; }
+  return "PERCEPTUAL";
+}
+
+export function analyzeArguments(paras: ParagraphAnalysis[]): ArgumentUnit[] {
+  return paras.map((p) => {
+    const cls = classifyPassage(p);
+    if (cls !== "ARGUMENTATIVE") {
+      return { paragraph: p.index, passageClass: cls, claim: null, reason: null, evidence: null, warrantExplicit: false, qualification: null, complete: true };
+    }
+    const claimS = p.sentences.find((s) => ARG_CLAIM_RE.test(s.text)) ?? p.sentences[0];
+    const reasonS = p.sentences.find((s) => ARG_REASON_RE.test(s.text));
+    const evidenceS = p.sentences.find((s) => ARG_EVIDENCE_RE.test(s.text));
+    const qualS = p.sentences.find((s) => ARG_QUALIFY_RE.test(s.text));
+    return {
+      paragraph: p.index, passageClass: cls,
+      claim: claimS?.text.slice(0, 90) ?? null,
+      reason: reasonS?.text.slice(0, 90) ?? null,
+      evidence: evidenceS?.text.slice(0, 90) ?? null,
+      warrantExplicit: !!reasonS && !!evidenceS,
+      qualification: qualS?.text.slice(0, 90) ?? null,
+      complete: !!claimS && !!reasonS && !!evidenceS,
+    };
+  });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// §13 AUREATE REVISION STACK — PASS-001..015 executed over real prose
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type PassResult = {
+  id: string; name: string; severity: "pass" | "warn" | "fail";
+  score: number; detail: string; findings: string[]; executable: boolean;
+};
+
+export type AureateContext = {
+  genome: StyleGenome;
+  /** reader-safe knowledge terms; anything outside is a curse-of-knowledge risk */
+  readerKnownTerms?: string[];
+  /** focal character name for POV audits */
+  focalCharacter?: string | null;
+  /** all cast names for dialogue attribution + idiolect distance */
+  castNames?: string[];
+  /** genre key for profile-relative thresholds */
+  genreKey?: string;
+};
+
+export function runRevisionStack(text: string, ctx: AureateContext): PassResult[] {
+  const sents = analyzeSentences(text);
+  const paras = analyzeParagraphs(text);
+  const g = ctx.genome;
+  const n = Math.max(1, sents.length);
+  const wAll = words(text); const W = Math.max(1, wAll.length);
+  const R: PassResult[] = [];
+  const push = (id: string, name: string, score: number, detail: string, findings: string[] = [], executable = true, warnAt = 0.65, failAt = 0.4) =>
+    R.push({ id, name, score: clamp01(score), detail, findings: findings.slice(0, 6), executable, severity: !executable ? "warn" : score >= warnAt ? "pass" : score >= failAt ? "warn" : "fail" });
+
+  // PASS-001 logic-to-prose alignment — every paragraph has an anchor
+  const anchored = paras.filter((p) => p.hasAnchor).length / Math.max(1, paras.length);
+  push("PASS-001", "Logic-to-prose alignment", anchored,
+    `${paras.filter((p) => p.hasAnchor).length}/${paras.length} paragraphs open on an actor or a concrete perception`,
+    paras.filter((p) => !p.hasAnchor).map((p) => `¶${p.index + 1}: "${p.text.slice(0, 50)}…"`));
+
+  // PASS-002 characters-as-subjects / actions-as-verbs (Williams)
+  const subjOk = sents.filter((s) => s.subjectIsCharacter).length / n;
+  const verbOk = sents.filter((s) => s.actionIsVerb).length / n;
+  const p002 = 0.5 * subjOk + 0.5 * verbOk;
+  push("PASS-002", "Characters-as-subjects / actions-as-verbs", p002,
+    `${(subjOk * 100).toFixed(0)}% sentences lead with an actor; ${(verbOk * 100).toFixed(0)}% carry the action in a finite verb`,
+    sents.filter((s) => !s.actionIsVerb).map((s) =>
+      `${s.lightVerbNominalization ? "light verb + nominalization" : s.passive ? "passive" : "nominalized"}: "${s.text.slice(0, 52)}…" [${s.nominalizations.slice(0, 2).join(", ")}]`));
+
+  // PASS-003 old-new information flow
+  const chain = sents.slice(1);
+  const oldNew = chain.length ? chain.filter((s) => s.oldBeforeNew).length / chain.length : 1;
+  push("PASS-003", "Old-before-new information flow", oldNew,
+    `${(oldNew * 100).toFixed(0)}% of sentences open on information the previous sentence established`,
+    chain.filter((s) => !s.oldBeforeNew).map((s) => `¶ break at "${s.text.slice(0, 50)}…"`));
+
+  // PASS-004 topic-stress / emphatic endings
+  const stress = sents.filter((s) => s.emphaticEnd).length / n;
+  push("PASS-004", "Topic-stress / emphatic endings", stress,
+    `${(stress * 100).toFixed(0)}% of sentences end on a content word rather than a function-word tail`,
+    sents.filter((s) => !s.emphaticEnd).map((s) => `weak end: "…${s.text.slice(-45)}"`));
+
+  // PASS-005 concision and clutter (Zinsser/Strunk) — profile-relative
+  const clutter = sents.reduce((a, s) => a + s.clutterHits.length, 0);
+  const wan = auditWanIntensifiers(text);
+  // NOTE: the package's `auditWanIntensifiers` returns `total` = TOTAL WORD
+  // COUNT (not hit count) and `density` = hits/words. Summing `findings` gives
+  // the actual hit count. Using `wan.total` here drove clutterRate to ~1.0 on
+  // every text and pinned PASS-005 to 0 — verified defect, fixed.
+  const wanHits = wan.findings.reduce((a, f) => a + f.count, 0);
+  const clutterRate = (clutter + wanHits) / W;
+  const cap = 0.012 + (1 - g.compression) * 0.02;
+  push("PASS-005", "Concision / clutter removal", clamp01(1 - clutterRate / Math.max(1e-6, cap)),
+    `clutter+intensifier rate ${(clutterRate * 100).toFixed(2)}% vs profile cap ${(cap * 100).toFixed(2)}% (compression ${g.compression})`,
+    [...new Set(sents.flatMap((s) => s.clutterHits))].concat(wan.findings.slice(0, 3).map((f) => `${f.word}×${f.count}`)));
+
+  // PASS-006 concrete-language strengthening (Strunk)
+  const concrete = sents.reduce((a, s) => a + s.concreteHits.length, 0);
+  const abstract = sents.reduce((a, s) => a + s.abstractHits.length, 0);
+  const concRate = concrete / Math.max(1, concrete + abstract);
+  const floor = 0.35 + g.concreteness * 0.35;
+  push("PASS-006", "Concrete-language strengthening", clamp01(concRate / Math.max(1e-6, floor)),
+    `concrete:abstract = ${concrete}:${abstract} (ratio ${(concRate * 100).toFixed(0)}%, profile floor ${(floor * 100).toFixed(0)}%)`,
+    [...new Set(sents.flatMap((s) => s.abstractHits))].map((x) => `abstract noun "${x}"`));
+
+  // PASS-007 copy-chief grammar hygiene (Dreyer) — HARD errors only
+  const hard: string[] = [];
+  if (/\ba\s+[aeiou]/i.test(text)) hard.push('article: "a" before a vowel sound');
+  if (/\bthe the\b|\band and\b|\bof of\b/i.test(text)) hard.push("doubled function word");
+  if (/\s[,.;:]\s?[,.;:]/.test(text)) hard.push("doubled punctuation");
+  const dq = (text.match(/"/g) ?? []).length, cq = (text.match(/[“”]/g) ?? []).length;
+  if (dq % 2 === 1 || cq % 2 === 1) hard.push("unbalanced quotation marks");
+  if (text.trim() && !/[.!?"'”’)\]]$/.test(text.trim())) hard.push("text does not terminate");
+  push("PASS-007", "Copy-chief grammar hygiene", hard.length === 0 ? 1 : 0,
+    hard.length ? `${hard.length} hard error(s) — these block release, unlike style preferences` : "no hard grammar errors detected (lexical check)",
+    hard, true, 0.99, 0.99);
+
+  // PASS-008 POV / focalization consistency
+  const povFindings: string[] = [];
+  if (FUTURE_LEAK_RE.test(text)) povFindings.push("future-knowledge leak into present focalization (POV-AUD-004)");
+  const others = (ctx.castNames ?? []).filter((c) => c && c !== ctx.focalCharacter);
+  for (const o of others) {
+    const re = new RegExp(`\\b${o}\\s+(?:felt|thought|knew|realised|realized|wondered)\\b`, "i");
+    if (re.test(text)) povFindings.push(`interior access to non-focal character "${o}" (POV-AUD-003)`);
+  }
+  const labels = (text.match(EMOTION_LABEL_RE) ?? []).length; EMOTION_LABEL_RE.lastIndex = 0;
+  if (g.focalDistance === "far" && labels > 0) povFindings.push(`${labels} direct emotion label(s) at far focal distance (POV-AUD-005)`);
+  push("PASS-008", "POV / focalization consistency", povFindings.length === 0 ? 1 : clamp01(1 - povFindings.length * 0.34),
+    povFindings.length ? `${povFindings.length} focalization issue(s)` : `focal distance ${g.focalDistance}; no leaks detected`, povFindings);
+
+  // PASS-009 image-chain coherence
+  const chains = extractImageChains(text);
+  const distinctHosts = (c: ImageFamily) => new Set(c.occurrences.map((o) => `${o.paragraph}:${o.sentence}`)).size;
+  const primary = chains.filter((c) => distinctHosts(c) >= 2);
+  const transformed = primary.filter((c) => c.transformed).length;
+  const tooMany = primary.length > 2;
+  const imgScore = primary.length === 0 ? (g.imageDensity > 0.6 ? 0.35 : 0.7)
+    : clamp01(transformed / primary.length) * (tooMany ? 0.7 : 1);
+  push("PASS-009", "Image-chain coherence", imgScore,
+    primary.length === 0 ? `no recurring image family (IMG-001: each major motif needs one)` :
+      `${primary.length} recurring famil${primary.length === 1 ? "y" : "ies"} (${primary.map((c) => c.sourceDomain).join(", ")}); ${transformed} recur in changed context${tooMany ? "; >2 primaries per scene (IMG-005)" : ""}`,
+    primary.filter((c) => !c.transformed).map((c) => `"${c.sourceDomain}" repeats without changing context (IMG-002)`));
+
+  // PASS-010 sound / rhythm variation
+  const sv = computeSoundVariables(text);
+  const rhythm = detectRhythmProfile(sv, sents);
+  let runs = 0, cur = 1;
+  for (let i = 1; i < sents.length; i++) { if (sents[i].rhythmClass === sents[i - 1].rhythmClass) { cur++; if (cur > 3) runs++; } else cur = 1; }
+  const lens = sents.map((s) => s.wordCount);
+  const mean = lens.reduce((a, b) => a + b, 0) / n;
+  const cv = mean > 0 ? Math.sqrt(lens.reduce((a, x) => a + (x - mean) ** 2, 0) / n) / mean : 0;
+  const rhyScore = clamp01(0.6 * clamp01(cv / 0.45) + 0.4 * (runs === 0 ? 1 : Math.max(0, 1 - runs * 0.3)));
+  push("PASS-010", "Sound / rhythm variation", rhyScore,
+    `profile ${rhythm} (${RHYTHM_PROFILE_NAMES[rhythm]}); length CV ${(cv * 100).toFixed(0)}%; ${runs} run(s) of >3 same-length sentences (RHY-AUD-001)`,
+    runs > 0 ? [`${runs} monotony run(s) — vary sentence length`] : []);
+
+  // PASS-011 dialogue idiolect and subtext
+  const turns = extractDialogue(text);
+  const bySpeaker = new Map<string, string[]>();
+  for (const t of turns) if (t.speaker) bySpeaker.set(t.speaker, [...(bySpeaker.get(t.speaker) ?? []), t.line]);
+  const vecs = [...bySpeaker.entries()].map(([k, v]) => ({ k, v: idiolectVector(v) }));
+  let minDist = 1;
+  for (let i = 0; i < vecs.length; i++) for (let j = i + 1; j < vecs.length; j++) minDist = Math.min(minDist, idiolectDistance(vecs[i].v, vecs[j].v));
+  const subtext = turns.length ? turns.filter((t) => t.hasSubtext).length / turns.length : 0;
+  const dialScore = turns.length === 0 ? (g.dialogueDensity > 0.6 ? 0.4 : 0.75)
+    : clamp01(0.5 * (vecs.length >= 2 ? clamp01(minDist / 0.18) : 0.6) + 0.5 * clamp01(subtext / 0.3));
+  push("PASS-011", "Dialogue idiolect and subtext", dialScore,
+    turns.length === 0 ? `no dialogue found (genome dialogueDensity ${g.dialogueDensity})` :
+      `${turns.length} turn(s), ${vecs.length} attributed speaker(s); min idiolect distance ${minDist.toFixed(3)} (DIA-AUD-002 ≥0.18); subtext in ${(subtext * 100).toFixed(0)}% of turns`,
+    vecs.length >= 2 && minDist < 0.18 ? ["two speakers share a near-identical idiolect vector"] : []);
+
+  // PASS-012 argument / warrant check
+  const args = analyzeArguments(paras);
+  const argUnits = args.filter((a) => a.passageClass === "ARGUMENTATIVE");
+  const argOk = argUnits.length === 0 ? 1 : argUnits.filter((a) => a.complete).length / argUnits.length;
+  push("PASS-012", "Argument / warrant check", argOk,
+    argUnits.length === 0 ? "no argumentative passage — lyrical/perceptual passages are exempt (§12.1)" :
+      `${argUnits.filter((a) => a.complete).length}/${argUnits.length} argumentative passages carry claim + reason + evidence`,
+    argUnits.filter((a) => !a.complete).map((a) => `¶${a.paragraph + 1}: missing ${!a.reason ? "reason" : "evidence"} (ARG-AUD-00${!a.reason ? "1" : "2"})`));
+
+  // PASS-013 cliché and stale phrase removal
+  const low = text.toLowerCase();
+  const cliches = CLICHE_LIST.filter((c) => low.includes(c));
+  push("PASS-013", "Cliché / stale phrase removal", cliches.length === 0 ? 1 : clamp01(1 - cliches.length * 0.25),
+    cliches.length ? `${cliches.length} cliché(s) from a ${CLICHE_LIST.length}-entry blacklist` : `0 hits against a ${CLICHE_LIST.length}-entry blacklist`,
+    cliches.map((c) => `"${c}"`));
+
+  // PASS-014 KALLOS-S is computed separately; record its inputs are ready
+  push("PASS-014", "KALLOS-S style scoring", 1, "computed by evaluateKallosS() from these passes", []);
+
+  // PASS-015 human-readability gate — NOT executable without a human
+  const pm = computeProseMetrics(text);
+  push("PASS-015", "Human-readability gate", 0.5,
+    `NOT EXECUTABLE: requires a human reader. Machine proxies only — Flesch ${pm.fleschReadingEase.toFixed(0)} (${pm.fleschLabel}), sentence σ ${pm.sentenceLenStdev.toFixed(1)}, distinct-word ${(pm.distinctWordRatio * 100).toFixed(0)}%.`,
+    ["v4 §19 STYLE-TEST-015 and v3 TEST-025 both require human review"], false);
+
+  return R;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// §14 KALLOS-S
+// ═══════════════════════════════════════════════════════════════════════════
+
+export const KALLOS_S_WEIGHTS: Record<string, number> = {
+  clarity: 0.14, cohesion: 0.10, concision: 0.10, concreteness: 0.09, rhythm: 0.09,
+  image_chain: 0.08, voice_distinction: 0.08, dialogue_subtext: 0.08, focal_integrity: 0.08,
+  syntactic_variety: 0.07, argument_warranting: 0.05, surprise_without_confusion: 0.04,
+};
+
+export type KallosSDim = { key: string; label: string; score: number; weight: number; detail: string };
+export type KallosSGate = { id: string; pass: boolean; detail: string; executable: boolean };
+export type KallosSReport = {
+  dims: KallosSDim[]; gates: KallosSGate[]; gatesPass: boolean;
+  composite: number; weakest: KallosSDim | null;
+  rhythmProfile: RhythmProfileId; soundVariables: SoundVariables;
+  passes: PassResult[]; method: string;
+};
+
+export function evaluateKallosS(text: string, ctx: AureateContext): KallosSReport {
+  const passes = runRevisionStack(text, ctx);
+  const byId = new Map(passes.map((p) => [p.id, p]));
+  const get = (id: string) => byId.get(id)?.score ?? 0.5;
+  const sents = analyzeSentences(text);
+  const sv = computeSoundVariables(text);
+  const rhythmProfile = detectRhythmProfile(sv, sents);
+
+  const distinctForms = new Set(sents.map((s) => s.syntaxForm)).size;
+  const variety = clamp01(distinctForms / 6);
+  const pm = computeProseMetrics(text);
+  const surprise = clamp01(0.5 * pm.distinctWordRatio * 1.6 + 0.5 * (1 - Math.min(1, pm.repeatedPhraseDensity * 20)));
+
+  const dims: KallosSDim[] = [
+    { key: "clarity", label: "clarity", score: 0.5 * get("PASS-002") + 0.5 * get("PASS-004"), weight: KALLOS_S_WEIGHTS.clarity, detail: "characters-as-subjects + topic/stress" },
+    { key: "cohesion", label: "cohesion", score: get("PASS-003"), weight: KALLOS_S_WEIGHTS.cohesion, detail: "old-before-new chain" },
+    { key: "concision", label: "concision", score: get("PASS-005"), weight: KALLOS_S_WEIGHTS.concision, detail: "clutter + intensifier rate vs profile cap" },
+    { key: "concreteness", label: "concreteness", score: get("PASS-006"), weight: KALLOS_S_WEIGHTS.concreteness, detail: "concrete:abstract ratio vs profile floor" },
+    { key: "rhythm", label: "rhythm", score: get("PASS-010"), weight: KALLOS_S_WEIGHTS.rhythm, detail: `length variance + monotony runs (${rhythmProfile})` },
+    { key: "image_chain", label: "image chain", score: get("PASS-009"), weight: KALLOS_S_WEIGHTS.image_chain, detail: "recurrence with changed context" },
+    { key: "voice_distinction", label: "voice distinction", score: get("PASS-011"), weight: KALLOS_S_WEIGHTS.voice_distinction, detail: "idiolect distance between speakers" },
+    { key: "dialogue_subtext", label: "dialogue subtext", score: get("PASS-011"), weight: KALLOS_S_WEIGHTS.dialogue_subtext, detail: "share of turns carrying subtext" },
+    { key: "focal_integrity", label: "focal integrity", score: get("PASS-008"), weight: KALLOS_S_WEIGHTS.focal_integrity, detail: "POV-AUD-001..005" },
+    { key: "syntactic_variety", label: "syntactic variety", score: variety, weight: KALLOS_S_WEIGHTS.syntactic_variety, detail: `${distinctForms} distinct syntax forms in use` },
+    { key: "argument_warranting", label: "argument warranting", score: get("PASS-012"), weight: KALLOS_S_WEIGHTS.argument_warranting, detail: "claim/reason/evidence on argumentative passages only" },
+    { key: "surprise_without_confusion", label: "surprise without confusion", score: surprise, weight: KALLOS_S_WEIGHTS.surprise_without_confusion, detail: "lexical freshness minus repeated phrases" },
+  ].map((d) => ({ ...d, score: Math.round(clamp01(d.score) * 1000) / 1000 }));
+
+  // §3.4 admissibility — "prose correct but dead".
+  // The v4 failure set (§3.4) explicitly includes "main action hidden in
+  // nominalization", "sentence rhythm monotonous" and "prose correct but dead".
+  // KALLOS-S §14 is a weighted SUM, so a passage can zero several dimensions and
+  // still clear the threshold on the strength of the others — verified by
+  // adversarial attack A1 ("Mara made a determination." ×5 scored 67.8).
+  // §3.4 is therefore enforced as its own admissibility gate rather than being
+  // folded into the score, which keeps §14's arithmetic spec-faithful.
+  const verbRate = sents.length ? sents.filter((x) => x.actionIsVerb).length / sents.length : 1;
+  const varietyScore = variety;
+  const concScore = get("PASS-006");
+  const rhythmScore = get("PASS-010");
+  const deadSignals = [
+    verbRate < 0.35 ? "action buried in nominalizations" : null,
+    varietyScore < 0.25 ? "syntactic monoculture" : null,
+    concScore < 0.20 ? "no concrete language" : null,
+    rhythmScore < 0.25 ? "monotonous rhythm" : null,
+  ].filter((x): x is string => x !== null);
+  const proseIsDead = sents.length >= 3 && deadSignals.length >= 3;
+
+  // §14 hard gates
+  const grammarPass = (byId.get("PASS-007")?.score ?? 0) >= 0.99;
+  const placeholder = /\{\{|\[TODO|TBD|lorem ipsum|\[insert/i.test(text);
+  const readerSafe = !FUTURE_LEAK_RE.test(text);
+  const povPass = (byId.get("PASS-008")?.score ?? 0) >= 0.65;
+  const logicPass = (byId.get("PASS-001")?.score ?? 0) >= 0.4;
+  const gates: KallosSGate[] = [
+    { id: "grammar", pass: grammarPass, executable: true, detail: byId.get("PASS-007")?.detail ?? "" },
+    { id: "logic", pass: logicPass, executable: true, detail: `paragraph anchoring ${(get("PASS-001") * 100).toFixed(0)}%` },
+    { id: "no_placeholder", pass: !placeholder, executable: true, detail: placeholder ? "placeholder token found" : "no placeholder tokens" },
+    { id: "reader_safe", pass: readerSafe, executable: true, detail: readerSafe ? "no future-knowledge leak" : "future-knowledge leak (curse of knowledge / POV-AUD-004)" },
+    { id: "POV", pass: povPass, executable: true, detail: byId.get("PASS-008")?.detail ?? "" },
+    { id: "not_dead", pass: !proseIsDead, executable: true,
+      detail: proseIsDead
+        ? `§3.4 "prose correct but dead": ${deadSignals.join("; ")}`
+        : `§3.4 alive — ${deadSignals.length}/4 death signals (needs ≥3 to fail)` },
+  ];
+  const gatesPass = gates.every((x) => x.pass);
+  const wsum = dims.reduce((a, d) => a + d.weight, 0) || 1;
+  const raw = dims.reduce((a, d) => a + d.weight * d.score, 0) / wsum;
+  const composite = gatesPass ? Math.round(raw * 1000) / 10 : 0;
+  const weakest = dims.reduce((a, d) => (d.score < a.score ? d : a), dims[0]);
+
+  return {
+    dims, gates, gatesPass, composite, weakest, rhythmProfile, soundVariables: sv, passes,
+    method:
+      "KALLOS-S is a lexical/heuristic style proxy: regex families, closed word lists, positional statistics and " +
+      "syllable counts over real text. No parser, no semantic model. Any hard gate failing sets KALLOS-S to 0 " +
+      "(v4 §14), including the §3.4 prose-correct-but-dead admissibility gate. " +
+      "PASS-015 (human readability) is NOT executable here and is excluded from the composite.",
+  };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// §15 STYLE-CGOL — prose morphogenesis over discourse units
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type StyleState = "spare" | "concrete" | "lyrical" | "procedural" | "comic" | "gothic" | "intimate" | "epic" | "reflective" | "tense";
+export type StyleCell = {
+  index: number; scale: "paragraph" | "sentence";
+  state: StyleState; support: number; neighbors: number[];
+  event: "BIRTH" | "SURVIVAL" | "DEATH" | "OVERPOPULATION" | "UNDERPOPULATION";
+  note: string;
+};
+export type StyleCgolRun = {
+  cells: StyleCell[];
+  pattern: "STILL-LIFE" | "OSCILLATOR" | "GLIDER" | "MIXED" | "EXTINCTION";
+  detail: string;
+  advice: string[];
+};
+
+function stateOfParagraph(p: ParagraphAnalysis, g: StyleGenome): { state: StyleState; support: number } {
+  const s = p.sentences; const mean = s.length ? s.reduce((a, x) => a + x.wordCount, 0) / s.length : 0;
+  const fig = s.reduce((a, x) => a + x.figurative, 0);
+  const conc = s.reduce((a, x) => a + x.concreteHits.length, 0);
+  if (p.type === "PAR-005") return { state: "intimate", support: 0.7 };
+  if (p.type === "PAR-006") return { state: "procedural", support: 0.8 };
+  if (p.type === "PAR-004") return { state: "reflective", support: 0.7 };
+  if (p.type === "PAR-010" || mean < 9) return { state: "tense", support: 0.75 };
+  if (fig >= 2 && mean > 20) return { state: "lyrical", support: clamp01(g.ornamentLevel + 0.2) };
+  if (mean > 30) return { state: g.proseMode === "gothic" ? "gothic" : "epic", support: 0.6 };
+  if (conc >= 2) return { state: "concrete", support: 0.8 };
+  if (mean < 14) return { state: "spare", support: clamp01(g.compression) };
+  return { state: "reflective", support: 0.5 };
+}
+
+export function runStyleCgol(text: string, g: StyleGenome): StyleCgolRun {
+  const paras = analyzeParagraphs(text);
+  // A 2-paragraph passage cannot exhibit an oscillator or a glider. The v4 §15.1
+  // StyleCell scale is explicitly {word|phrase|sentence|paragraph|scene|chapter},
+  // so fall back to SENTENCE scale when the paragraph lattice is too small to
+  // carry a pattern — otherwise every short passage reported "MIXED" (defect).
+  if (paras.length < 4) {
+    const sent = analyzeSentences(text);
+    if (sent.length >= 4) {
+      const synth: ParagraphAnalysis[] = sent.map((sa, i) => ({
+        index: i, text: sa.text, type: classifyParagraph(sa.text, [sa]), sentences: [sa],
+        hasAnchor: sa.subjectIsCharacter || sa.concreteHits.length > 0,
+        oldNewChainRatio: sa.oldBeforeNew === false ? 0 : 1,
+        finalSentenceStress: sa.emphaticEnd,
+        abstractionAnchored: sa.abstractHits.length === 0 || sa.concreteHits.length >= 1,
+        lengthSentences: 1,
+        move: { anchor: sa.text.slice(0, 60), development: "", turn: "", stress: sa.text.slice(-40) },
+      }));
+      return cgolOver(synth, g, "sentence");
+    }
+  }
+  return cgolOver(paras, g, "paragraph");
+}
+
+function cgolOver(paras: ParagraphAnalysis[], g: StyleGenome, scale: "paragraph" | "sentence"): StyleCgolRun {
+  const cells: StyleCell[] = [];
+  for (let i = 0; i < paras.length; i++) {
+    const { state, support } = stateOfParagraph(paras[i], g);
+    const prev = cells[i - 1];
+    const effectCount =
+      (paras[i].sentences.reduce((a, s) => a + s.figurative, 0) >= 2 ? 1 : 0) +
+      (paras[i].sentences.some((s) => s.rhythmClass === "very-long") ? 1 : 0) +
+      (paras[i].sentences.reduce((a, s) => a + s.adverbs.length, 0) >= 3 ? 1 : 0) +
+      (paras[i].sentences.reduce((a, s) => a + s.concreteHits.length, 0) >= 4 ? 1 : 0);
+    let event: StyleCell["event"] = "BIRTH"; let note = `${state} enters`;
+    if (prev && prev.state === state) { event = "SURVIVAL"; note = `${state} persists (supported ${support.toFixed(2)})`; }
+    if (prev && prev.state === state && support < 0.45) { event = "DEATH"; note = `${state} unsupported — retire the register`; }
+    if (effectCount >= 3) { event = "OVERPOPULATION"; note = `${effectCount} style effects in one paragraph — simplify`; }
+    if (effectCount === 0 && support < 0.5) { event = "UNDERPOPULATION"; note = "bland paragraph — inject image, rhythm or voice contrast"; }
+    cells.push({ index: i, scale, state, support, neighbors: [i - 1, i + 1].filter((x) => x >= 0 && x < paras.length), event, note });
+  }
+  const states = cells.map((c) => c.state);
+  const uniq = new Set(states).size;
+  let pattern: StyleCgolRun["pattern"] = "MIXED";
+  let detail = `${uniq} distinct style states across ${cells.length} ${scale}s`;
+  if (cells.length === 0) { pattern = "EXTINCTION"; detail = "no paragraphs"; }
+  else if (uniq === 1) { pattern = "STILL-LIFE"; detail = `stable ${states[0]} register throughout`; }
+  else if (cells.length >= 4 && states.every((s, i) => i < 2 || s === states[i - 2])) { pattern = "OSCILLATOR"; detail = "period-2 alternation of registers"; }
+  else if (uniq >= 3 && states[0] !== states[states.length - 1]) { pattern = "GLIDER"; detail = `register migrates ${states[0]} → ${states[states.length - 1]}`; }
+  const advice = cells.filter((c) => c.event === "OVERPOPULATION" || c.event === "UNDERPOPULATION" || c.event === "DEATH")
+    .map((c) => `¶${c.index + 1}: ${c.note}`);
+  return { cells, pattern, detail, advice };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// §19 STYLE-TEST-001..015
+// ═══════════════════════════════════════════════════════════════════════════
+
+export type StyleTest = { id: string; name: string; status: "PASS" | "FAIL" | "NOT_EXECUTABLE"; detail: string };
+
+export function runStyleTests(text: string, ctx: AureateContext, opts?: { replayHashA?: string; replayHashB?: string }): StyleTest[] {
+  const k = evaluateKallosS(text, ctx);
+  const byId = new Map(k.passes.map((p) => [p.id, p]));
+  const g = ctx.genome;
+  const sents = analyzeSentences(text);
+  const t: StyleTest[] = [];
+  const add = (id: string, name: string, status: StyleTest["status"], detail: string) => t.push({ id, name, status, detail });
+  const gate = (id: string, name: string, score: number, floor: number, detail: string) =>
+    add(id, name, score >= floor ? "PASS" : "FAIL", `${detail} (score ${score.toFixed(2)} vs floor ${floor})`);
+
+  gate("STYLE-TEST-001", "characters/actions alignment", byId.get("PASS-002")?.score ?? 0, 0.55, byId.get("PASS-002")?.detail ?? "");
+  gate("STYLE-TEST-002", "old-new information chain", byId.get("PASS-003")?.score ?? 0, 0.5, byId.get("PASS-003")?.detail ?? "");
+  gate("STYLE-TEST-003", "topic-stress endings", byId.get("PASS-004")?.score ?? 0, 0.6, byId.get("PASS-004")?.detail ?? "");
+  gate("STYLE-TEST-004", "clutter ratio below cap", byId.get("PASS-005")?.score ?? 0, 0.5, byId.get("PASS-005")?.detail ?? "");
+  gate("STYLE-TEST-005", "concrete-language density", byId.get("PASS-006")?.score ?? 0, 0.45, byId.get("PASS-006")?.detail ?? "");
+  const cl = byId.get("PASS-013");
+  add("STYLE-TEST-006", "cliché blacklist zero", (cl?.findings.length ?? 0) === 0 ? "PASS" : "FAIL", cl?.detail ?? "");
+  gate("STYLE-TEST-007", "POV metaphor ownership", byId.get("PASS-008")?.score ?? 0, 0.65, byId.get("PASS-008")?.detail ?? "");
+  const turns = extractDialogue(text);
+  const bySpeaker = new Map<string, string[]>();
+  for (const x of turns) if (x.speaker) bySpeaker.set(x.speaker, [...(bySpeaker.get(x.speaker) ?? []), x.line]);
+  if (bySpeaker.size < 2) add("STYLE-TEST-008", "idiolect distance between leads", "NOT_EXECUTABLE", `needs ≥2 attributed speakers; found ${bySpeaker.size}`);
+  else {
+    const vs = [...bySpeaker.values()].map(idiolectVector);
+    let md = 1; for (let i = 0; i < vs.length; i++) for (let j = i + 1; j < vs.length; j++) md = Math.min(md, idiolectDistance(vs[i], vs[j]));
+    add("STYLE-TEST-008", "idiolect distance between leads", md >= 0.18 ? "PASS" : "FAIL", `min distance ${md.toFixed(3)} vs floor 0.18`);
+  }
+  const distinctHosts2 = (c: ImageFamily) => new Set(c.occurrences.map((o) => `${o.paragraph}:${o.sentence}`)).size;
+  const chains = extractImageChains(text).filter((c) => distinctHosts2(c) >= 2);
+  if (chains.length === 0) add("STYLE-TEST-009", "image-chain recurrence transformed", "NOT_EXECUTABLE", "no image family recurs; nothing to transform");
+  else add("STYLE-TEST-009", "image-chain recurrence transformed", chains.every((c) => c.transformed) ? "PASS" : "FAIL",
+    `${chains.filter((c) => c.transformed).length}/${chains.length} families recur in a changed context`);
+  gate("STYLE-TEST-010", "sound/rhythm variance", byId.get("PASS-010")?.score ?? 0, 0.5, byId.get("PASS-010")?.detail ?? "");
+  gate("STYLE-TEST-011", "argument/warrant complete", byId.get("PASS-012")?.score ?? 0, 0.99, byId.get("PASS-012")?.detail ?? "");
+  add("STYLE-TEST-012", "grammar hard errors zero", (byId.get("PASS-007")?.findings.length ?? 0) === 0 ? "PASS" : "FAIL", byId.get("PASS-007")?.detail ?? "");
+  const ph = /\{\{|\[TODO|TBD|lorem ipsum|\[insert/i.test(text) || (text.trim() !== "" && !/[.!?"'”’)\]]$/.test(text.trim()));
+  add("STYLE-TEST-013", "no placeholders/truncation", ph ? "FAIL" : "PASS", ph ? "placeholder or truncated ending detected" : "no placeholders; text terminates");
+  const thresh = Math.round((45 + g.clarityLevel * 25));
+  add("STYLE-TEST-014", "KALLOS-S ≥ release threshold", k.composite >= thresh ? "PASS" : "FAIL", `KALLOS-S ${k.composite} vs profile threshold ${thresh}${k.gatesPass ? "" : " (hard gate failed ⇒ 0)"}`);
+  if (opts?.replayHashA && opts?.replayHashB) add("STYLE-TEST-015", "seed replay byte-identical", opts.replayHashA === opts.replayHashB ? "PASS" : "FAIL", `${opts.replayHashA.slice(0, 12)} vs ${opts.replayHashB.slice(0, 12)}`);
+  else add("STYLE-TEST-015", "seed replay byte-identical", "NOT_EXECUTABLE", "supply two replay hashes of the same seed to execute this test");
+  void sents;
+  return t;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Directive block — what v4 contributes to the LLM prompt
+// ═══════════════════════════════════════════════════════════════════════════
+
+const MODE_GUIDANCE: Record<ProseMode, string> = {
+  classic: "Classic style: the prose points at something in the world and lets the reader see it. No throat-clearing, no meta-commentary.",
+  transparent: "Transparent style: the sentence disappears; only the event remains. Plain verbs, ordinary syntax.",
+  lyrical: "Lyrical style: sound carries meaning. Long syntactic curves are allowed, but every curve must land on an image.",
+  spare: "Spare style: short declaratives. Cut every word that does not change the picture.",
+  baroque: "Baroque style: accumulation and subordination, but each clause must add a fact, not an adjective.",
+  comic: "Comic style: setup and snap. Put the funny word last.",
+  gothic: "Gothic style: accumulation toward dread. Concrete decay imagery, slow clauses, hard stops.",
+  procedural: "Procedural style: sequence, measurement, and consequence. Numbers carry units.",
+  intimate: "Intimate style: close focal distance, small physical gestures, restrained emotion naming.",
+  epic: "Epic style: wide focal distance, long roll, but ground every abstraction in one concrete object.",
+};
+
+export function buildAureateDirective(g: StyleGenome, pack: StylePackId | null, opts?: { chapterWords?: number }): string {
+  const wordsTarget = Math.max(300, opts?.chapterWords ?? 1200);
+  const clutterCap = Math.round((0.012 + (1 - g.compression) * 0.02) * wordsTarget);
+  const concreteFloor = Math.max(3, Math.round((0.35 + g.concreteness * 0.35) * (wordsTarget / 120)));
+  const longAllowed = g.syntacticComplexity > 0.55;
+  return [
+    "AUREATE-SCRIBE STYLE CONTRACT (v4 · apply silently; never name these rules in the prose):",
+    `- Prose mode: ${g.proseMode}. ${MODE_GUIDANCE[g.proseMode]}`,
+    pack ? `- Style pack: ${pack} — ${STYLE_PACK_DELTAS[pack].note}.` : "",
+    `- Focal distance: ${g.focalDistance}. Every metaphor, every judgement and every sensory detail must belong to that position. No future knowledge, no access to a mind the focal position cannot reach.`,
+    "- Williams: the main character of each sentence is its grammatical subject; the main action is a finite verb, not a noun ending in -tion/-ment/-ance.",
+    "- Williams: open each sentence on information the previous sentence established, and end on the new, stressed idea. Do not end on a function word.",
+    `- Strunk/Zinsser: cut clutter. Budget ≈ ${clutterCap} clutter phrases or intensifiers for this chapter, and prefer fewer.`,
+    `- Strunk: prefer definite, concrete, specific language. Aim for ≥ ${concreteFloor} concrete physical nouns in this chapter.`,
+    `- Le Guin/Tufte: vary sentence length deliberately. Never write more than three consecutive sentences of the same length class.${longAllowed ? " Long syntactic curves are permitted when they land on an image." : " Keep syntax simple; long curves are not in this profile."}`,
+    `- Image discipline: at most 2 primary image families in a scene; when a motif returns, its context must have changed. No dead metaphor unless a character's voice requires it.`,
+    "- Dreyer: hard grammar errors block release; style preferences are negotiable. No doubled punctuation, no unbalanced quotation marks.",
+    "- Dialogue: every line performs a speech act (question, request, refusal, accusation, commitment, evasion). Two characters must never sound alike. Emotionally loaded scenes carry subtext, not statement.",
+    "- Booth: if a passage makes an argument, it must carry claim → reason → evidence. Lyrical and perceptual passages are exempt and must not be forced into essay logic.",
+    "- Pinker: write from what the reader currently knows. Do not assume the reader shares knowledge the text has not supplied.",
+    "- Forbidden: clichés from the common stock (\"heart skipped a beat\", \"deafening silence\", \"little did she know\", \"let out a breath she didn't know she was holding\"), placeholders, and unfinished sentences.",
+  ].filter(Boolean).join("\n");
+}
+
+/** Compact genome line for the archetype set. */
+export function genomeSummary(g: StyleGenome, pack: StylePackId | null): string {
+  return `${g.proseMode}/${g.focalDistance}${pack ? ` · ${pack}` : ""} · clarity ${g.clarityLevel.toFixed(2)} · ornament ${g.ornamentLevel.toFixed(2)} · music ${g.sentenceMusic.toFixed(2)} · syntax ${g.syntacticComplexity.toFixed(2)} · concrete ${g.concreteness.toFixed(2)} · compression ${g.compression.toFixed(2)}`;
+}