2sagaco48 1.0.0

package/src/fiction/nive-engine.ts

@@ -0,0 +1,404 @@
+/**
+ * NARRATIVE INTEGRITY & VERIFICATION ENGINE (NIVE) — TypeScript / Web Runtime
+ * ---------------------------------------------------------------------------
+ * Faithfully ports and elevates the Section 6 Python reference engine into a
+ * production-grade, zero-dependency, deterministic TypeScript audit system.
+ *
+ * Implements full programmatic auditing for:
+ *   1. PROMPT_SCAFFOLDING_LEAK (A.3.1): Developer metadata, word bounds, NIH/SABV tags.
+ *   2. EXACT_CLONED_CHAPTER_OPENING & FORMULAIC_OPENINGS (B.2.2 / B.3.1):
+ *      Detects identical multi-word opening sentences across chapters and
+ *      rigid procedural frames like "First, because...".
+ *   3. CHARACTER_RESURRECTION_VIOLATION (B.1.1): Monotonic mortality tracking
+ *      where post-mortem somatic action or dialogue attribution triggers a violation.
+ *   4. ONTOLOGICAL_METAMORPHOSIS (B.1.2): Detects archetype confusion (e.g. unicorn
+ *      entity shifting from mare to male hermit to female cottage archivist to chimera).
+ *   5. COUNTERFACTUAL_IDENTITY_MUTATION (A.1.1): Detects the 15-fold unlived life
+ *      mutating professions and swapping biological sex across chapters.
+ *   6. SENTENCE_LENGTH_CONSTRAINT_FAILURE (A.3.2): Checks min/max word boundary
+ *      infractions per sentence.
+ *   7. MOTIF_BUDGET_EXCEEDED (A.3.2): Frequency tracking for over-primed motif words.
+ *   8. MODULO_SPATIAL_CAROUSEL_TRAP (A.2.1 / B.2.1): Detects cyclical setting ping-pong.
+ *   9. MACGUFFIN_INSTABILITY (A.2.2): Detects core truth object shifting physical forms.
+ *  10. CLIMAX_EVASION_ADMINISTRATIVE (A.2.3 / B.2.3): Flags resolutions settled by
+ *      clerical leases, fines, or permits instead of dramatic confrontations.
+ */
+
+export interface ParsedChapter {
+  chapterIndex: number;
+  rawHeader: string;
+  leakedHeaders: string[];
+  cleanNarrative: string;
+}
+
+export interface NIVEViolation {
+  type:
+    | "PROMPT_SCAFFOLDING_LEAK"
+    | "EXACT_CLONED_CHAPTER_OPENING"
+    | "FORMULAIC_SYNTACTIC_OPENING"
+    | "CHARACTER_RESURRECTION_VIOLATION"
+    | "ONTOLOGICAL_METAMORPHOSIS"
+    | "COUNTERFACTUAL_IDENTITY_MUTATION"
+    | "SENTENCE_LENGTH_CONSTRAINT_FAILURE"
+    | "MOTIF_BUDGET_EXCEEDED"
+    | "MODULO_SPATIAL_CAROUSEL_TRAP"
+    | "MACGUFFIN_INSTABILITY"
+    | "CLIMAX_EVASION_ADMINISTRATIVE";
+  severity: "critical" | "warning" | "info";
+  chapter?: number;
+  chapters?: number[];
+  character?: string;
+  count?: number;
+  evidence?: string[];
+  details?: Record<string, unknown>;
+  message: string;
+}
+
+export interface NIVEConfig {
+  sentenceRange?: [number, number];
+  motifLimits?: Record<string, number>;
+  mortality?: Record<string, number>; // character name -> chapter index of somatic death
+  trackCounterfactual?: boolean;
+  trackCarousel?: boolean;
+}
+
+export class NarrativeIntegrityEngine {
+  public rawText: string;
+  public manuscriptId: string;
+  public config: NIVEConfig;
+  public chapters: ParsedChapter[] = [];
+  public violations: NIVEViolation[] = [];
+
+  constructor(text: string, manuscriptId = "MS-ACTIVE", config: NIVEConfig = {}) {
+    this.rawText = text || "";
+    this.manuscriptId = manuscriptId;
+    this.config = {
+      sentenceRange: [6, 28],
+      motifLimits: { truth: 6, cold: 6, vault: 6, refrigeratory: 3, borderland: 6 },
+      trackCounterfactual: true,
+      trackCarousel: true,
+      ...config,
+    };
+    this.parseChapters();
+  }
+
+  private parseChapters(): void {
+    if (!this.rawText.trim()) return;
+
+    // Split on Markdown chapter headings (## N.) or standard numbered chapters
+    const splitRegex = /(?:^|\n)(?=(?:##\s+(?:\d+\.?\s*)?|\b\d+\.\s+[A-Z]))/i;
+    const rawSegments = this.rawText.trim().split(splitRegex).map((s) => s.trim()).filter(Boolean);
+
+    let idx = 1;
+    for (const raw of rawSegments) {
+      const lines = raw.split("\n");
+      const header = lines[0]?.trim() || `Chapter ${idx}`;
+      const bodyLines = lines.slice(1);
+
+      const leakedHeaders: string[] = [];
+      const cleanLines: string[] = [];
+
+      for (const line of bodyLines) {
+        const lStr = line.trim();
+        if (
+          [
+            "Title:", "Chapter:", "POV:", "Tone:", "Setting:", "Characters:",
+            "World Mechanisms:", "Relationship Texture:", "Reality Grounding:",
+            "Reality Level:", "Dramatic Job:", "Beat to realize:", "Constraint:",
+            "Prose Constraints:", "Target Length:", "Specifics Floor:", "Key Beat:",
+            "Specific Device:", "Genre:", "Stakes Rotation:",
+          ].some((prefix) => lStr.startsWith(prefix)) ||
+          [
+            "Self-Correction during drafting", "Check:", "SABV", "L5 Realist?",
+            "Let's write", "Let's begin", "Writing...", "Let's execute",
+            "CONTINUITY LEDGER —", "STRUCTURAL OBLIGATION —", "CRAFT BUDGETS FOR THIS CHAPTER",
+            "_Resuming at chapter", "chapter(s) restored, not regenerated",
+          ].some((needle) => lStr.includes(needle))
+        ) {
+          leakedHeaders.push(line);
+        } else {
+          cleanLines.push(line);
+        }
+      }
+
+      const cleanText = cleanLines.join("\n").trim();
+      this.chapters.push({
+        chapterIndex: idx++,
+        rawHeader: header,
+        leakedHeaders,
+        cleanNarrative: cleanText,
+      });
+    }
+  }
+
+  public auditPromptScaffoldingLeaks(): void {
+    for (const ch of this.chapters) {
+      if (ch.leakedHeaders.length > 0) {
+        this.violations.push({
+          type: "PROMPT_SCAFFOLDING_LEAK",
+          severity: "critical",
+          chapter: ch.chapterIndex,
+          count: ch.leakedHeaders.length,
+          evidence: ch.leakedHeaders.slice(0, 3),
+          message: `Chapter ${ch.chapterIndex} contains ${ch.leakedHeaders.length} leaked prompt metadata or scratchpad line(s).`,
+        });
+      }
+    }
+  }
+
+  public auditClonedChapterOpenings(): void {
+    const openings: Map<number, string> = new Map();
+    for (const ch of this.chapters) {
+      const sentences = ch.cleanNarrative
+        .replace(/\s+/g, " ")
+        .split(/(?<=[.!?])\s+/)
+        .map((s) => s.trim())
+        .filter((s) => s.length > 15);
+      if (sentences.length > 0) {
+        openings.set(ch.chapterIndex, sentences[0]);
+      }
+    }
+
+    const indices = Array.from(openings.keys());
+    for (let i = 0; i < indices.length; i++) {
+      for (let j = i + 1; j < indices.length; j++) {
+        const id1 = indices[i];
+        const id2 = indices[j];
+        const s1 = openings.get(id1)!;
+        const s2 = openings.get(id2)!;
+
+        // Exact cloned opening
+        if (s1.toLowerCase() === s2.toLowerCase()) {
+          this.violations.push({
+            type: "EXACT_CLONED_CHAPTER_OPENING",
+            severity: "critical",
+            chapters: [id1, id2],
+            evidence: [s1],
+            message: `Chapters ${id1} and ${id2} share an identical opening sentence (Few-Shot Prompt Cloning).`,
+          });
+        } else if (
+          s1.toLowerCase().startsWith("first, because") &&
+          s2.toLowerCase().startsWith("first, because")
+        ) {
+          this.violations.push({
+            type: "FORMULAIC_SYNTACTIC_OPENING",
+            severity: "warning",
+            chapters: [id1, id2],
+            evidence: [s1.slice(0, 60), s2.slice(0, 60)],
+            message: `Chapters ${id1} and ${id2} use rigid syntactic templating ("First, because...").`,
+          });
+        }
+      }
+    }
+  }
+
+  public auditCharacterMortality(mortalityRules?: Record<string, number>): void {
+    const rules = mortalityRules || this.config.mortality;
+    if (!rules) return;
+
+    const esc = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    for (const [charName, deathCh] of Object.entries(rules)) {
+      const cn = esc(charName);
+      for (const ch of this.chapters) {
+        if (ch.chapterIndex > deathCh) {
+          let matches: RegExpMatchArray | null = null;
+          try {
+            const actionPattern = new RegExp(
+              `(?:"${cn}\\s+(?:said|replied|whispered|murmured|asked|shouted)|(?:said|replied|whispered|murmured)\\s+${cn}|\\b${cn}\\s+(?:walked|stepped|turned|looked|reached|shoved|stirred|held|pulled|struck|sat|stood|laughed|nodded|chose|spoke)\\b)`,
+              "i"
+            );
+            matches = ch.cleanNarrative.match(actionPattern);
+          } catch {
+            matches = null; // malformed name → skip this rule rather than crash the whole scan
+          }
+          if (matches) {
+            this.violations.push({
+              type: "CHARACTER_RESURRECTION_VIOLATION",
+              severity: "critical",
+              character: charName,
+              chapter: ch.chapterIndex,
+              evidence: matches.slice(0, 2),
+              message: `Character "${charName}" was somatically deceased in Ch ${deathCh} but resumes active dialogue or agency in Ch ${ch.chapterIndex}.`,
+            });
+          }
+        }
+      }
+    }
+  }
+
+  public auditCounterfactualStability(): void {
+    const professions = [
+      "baker", "administrator", "vault clerk", "scholar", "gardener",
+      "clockmaker", "carpenter", "quarry laborer", "mason", "surveyor",
+    ];
+    const occurrences: Array<{ chapter: number; profession: string; isFemale?: boolean }> = [];
+
+    for (const ch of this.chapters) {
+      const textLower = ch.cleanNarrative.toLowerCase();
+      if (
+        textLower.includes("unlived") ||
+        textLower.includes("counterfactual") ||
+        textLower.includes("life he didn't choose") ||
+        textLower.includes("version of yourself") ||
+        textLower.includes("foreclosed future")
+      ) {
+        for (const prof of professions) {
+          if (textLower.includes(prof)) {
+            const isFemale = /\b(?:woman|she|wife|her|baker's daughter|elder songs)\b/i.test(ch.cleanNarrative);
+            occurrences.push({ chapter: ch.chapterIndex, profession: prof, isFemale });
+            break;
+          }
+        }
+      }
+    }
+
+    const uniqueProfs = new Set(occurrences.map((o) => o.profession));
+    if (uniqueProfs.size >= 3) {
+      this.violations.push({
+        type: "COUNTERFACTUAL_IDENTITY_MUTATION",
+        severity: "critical",
+        count: uniqueProfs.size,
+        evidence: occurrences.map((o) => `Ch ${o.chapter}: ${o.profession}${o.isFemale ? " (Sex Flip)" : ""}`),
+        message: `The protagonist's counterfactual unlived life mutated across ${uniqueProfs.size} distinct identities without dynamic state anchoring.`,
+      });
+    }
+  }
+
+  public auditSentenceLengths(): void {
+    if (!this.config.sentenceRange) return;
+    const [minLen, maxLen] = this.config.sentenceRange;
+    let totalSentences = 0;
+    const infractions: Array<{ chapter: number; length: number; snippet: string }> = [];
+
+    for (const ch of this.chapters) {
+      const sents = ch.cleanNarrative
+        .replace(/\s+/g, " ")
+        .split(/(?<=[.!?])\s+/)
+        .map((s) => s.trim())
+        .filter((s) => s.length > 5);
+
+      for (const sent of sents) {
+        const words = sent.split(/\s+/).filter(Boolean);
+        const wCount = words.length;
+        totalSentences++;
+        if (wCount < minLen || wCount > maxLen) {
+          infractions.push({
+            chapter: ch.chapterIndex,
+            length: wCount,
+            snippet: sent.slice(0, 60),
+          });
+        }
+      }
+    }
+
+    const violationRate = totalSentences > 0 ? (infractions.length / totalSentences) * 100 : 0;
+    if (violationRate > 15.0) {
+      this.violations.push({
+        type: "SENTENCE_LENGTH_CONSTRAINT_FAILURE",
+        severity: "warning",
+        count: infractions.length,
+        details: { totalSentences, violationRate: Math.round(violationRate * 10) / 10 },
+        evidence: infractions.slice(0, 4).map((i) => `Ch ${i.chapter} (${i.length}w): "${i.snippet}..."`),
+        message: `${Math.round(violationRate)}% of sentences violate the [${minLen}, ${maxLen}] word length constraint.`,
+      });
+    }
+  }
+
+  public auditMotifFrequencies(): void {
+    if (!this.config.motifLimits) return;
+    const fullText = this.chapters.map((c) => c.cleanNarrative).join(" ").toLowerCase();
+
+    const escM = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    for (const [motif, limit] of Object.entries(this.config.motifLimits)) {
+      let matches: RegExpMatchArray | null = null;
+      try {
+        matches = fullText.match(new RegExp(`\\b${escM(motif)}\\b`, "gi"));
+      } catch {
+        matches = null;
+      }
+      const count = matches ? matches.length : 0;
+      if (count > limit) {
+        this.violations.push({
+          type: "MOTIF_BUDGET_EXCEEDED",
+          severity: "warning",
+          count,
+          details: { motif, limit, actual: count, overflowRatio: Math.round((count / limit) * 10) / 10 },
+          message: `Motif "${motif}" appeared ${count} times (budget: ${limit}; exceeded by ${(count / limit).toFixed(1)}x).`,
+        });
+      }
+    }
+  }
+
+  public auditSpatialCarousel(): void {
+    // Detect cyclic ping-pong between <= 3 locations across 6+ chapters
+    const placePattern = /\b(?:Borderland|Dystopia|Village|Tulkaaklang|Granary Tower|Tanyard|Tithe Barn|Holdstrketh)\b/gi;
+    const trajectory: Array<{ chapter: number; place: string }> = [];
+
+    for (const ch of this.chapters) {
+      const match = ch.cleanNarrative.match(placePattern);
+      if (match) {
+        trajectory.push({ chapter: ch.chapterIndex, place: match[0].toLowerCase() });
+      }
+    }
+
+    if (trajectory.length >= 6) {
+      const distinct = new Set(trajectory.map((t) => t.place));
+      if (distinct.size <= 3 && trajectory.length >= 6) {
+        this.violations.push({
+          type: "MODULO_SPATIAL_CAROUSEL_TRAP",
+          severity: "warning",
+          count: trajectory.length,
+          evidence: trajectory.slice(0, 6).map((t) => `Ch ${t.chapter} -> ${t.place}`),
+          message: `Characters are trapped in a modulo setting carousel cycling between only ${distinct.size} locations across ${trajectory.length} checkpoints.`,
+        });
+      }
+    }
+  }
+
+  public auditClimaxEvasion(): void {
+    const finalChapters = this.chapters.slice(-3);
+    for (const ch of finalChapters) {
+      const match = ch.cleanNarrative.match(
+        /\b(?:lease has expired|administrative decree|renewal of records|petition is denied|court will issue an injunction|filing of an audit|fine of \d+)\b/i
+      );
+      if (match) {
+        this.violations.push({
+          type: "CLIMAX_EVASION_ADMINISTRATIVE",
+          severity: "critical",
+          chapter: ch.chapterIndex,
+          evidence: [match[0]],
+          message: `Act III Climax (Ch ${ch.chapterIndex}) was resolved by administrative paperwork ("${match[0]}") rather than dramatic confrontation.`,
+        });
+      }
+    }
+  }
+
+  public runAllAudits(): {
+    manuscriptId: string;
+    chapterCount: number;
+    totalViolations: number;
+    violations: NIVEViolation[];
+    cleanScore: number;
+  } {
+    this.auditPromptScaffoldingLeaks();
+    this.auditClonedChapterOpenings();
+    this.auditCharacterMortality();
+    if (this.config.trackCounterfactual) this.auditCounterfactualStability();
+    this.auditSentenceLengths();
+    this.auditMotifFrequencies();
+    if (this.config.trackCarousel) this.auditSpatialCarousel();
+    this.auditClimaxEvasion();
+
+    const criticals = this.violations.filter((v) => v.severity === "critical").length;
+    const warnings = this.violations.filter((v) => v.severity === "warning").length;
+    const cleanScore = Math.max(0, 100 - criticals * 20 - warnings * 8);
+
+    return {
+      manuscriptId: this.manuscriptId,
+      chapterCount: this.chapters.length,
+      totalViolations: this.violations.length,
+      violations: this.violations,
+      cleanScore,
+    };
+  }
+}

package/src/fiction/pipeline-selftest.ts

@@ -0,0 +1,132 @@
+/**
+ * PIPELINE SELF-TEST — pure, no network, no LLM.
+ * ---------------------------------------------------------------------------
+ * Proves the fiction generation stack can commit a full N-chapter novel
+ * without stalls, truncations, or chapter-count drift. Uses a deterministic
+ * mock generator so the test is reproducible in the build environment.
+ *
+ * What it verifies (hand-traceable):
+ *   1. parseChaptersFromText is stable on ##-headed manuscripts
+ *   2. foldFacts / continuity ledger stays bounded across N chapters
+ *   3. stripHarnessResidue kills resumption notices / scaffolding bleed
+ *   4. A full N-chapter commit loop yields exactly N chapters (no stuck chapter)
+ *   5. Seed locks apply to snapshot without throwing
+ *   6. decayEditBudget + classifyRevisionUnits stay honest under known diffs
+ */
+import { parseChaptersFromText } from "./story-engine";
+import {
+  EMPTY_LEDGER,
+  extractChapterFacts,
+  foldFacts,
+  stripHarnessResidue,
+  truncationVerdict,
+  normalizeChapterTitle,
+} from "./continuity";
+import { applySeedLocks, DEFAULT_SEED_CONTROL, selectSeedDirectives, buildSeedDirectiveBlock } from "./seed-control";
+import { createStorySnapshot } from "./story-engine";
+import { classifyRevisionUnits, decayEditBudget } from "../lib/ai-revision";
+
+export type SelfTestCase = { name: string; pass: boolean; detail?: string };
+export type SelfTestReport = { pass: boolean; cases: SelfTestCase[]; ranAt: number };
+
+function mockChapter(i: number, title: string): string {
+  // Deterministic multi-paragraph body well above the 40-char parse floor and
+  // above the 60% truncation threshold for a 400-word commission.
+  const sentences = Array.from({ length: 24 }, (_, s) =>
+    `In scene ${s + 1} of chapter ${i}, the courier crossed the limestone step and noted the iron latch on the east door.`,
+  );
+  return `## ${title}\n\n${sentences.join(" ")}`;
+}
+
+export function runFictionPipelineSelfTest(chapterCount = 16): SelfTestReport {
+  const cases: SelfTestCase[] = [];
+  const seed = 42;
+
+  // 1. Title normalization
+  cases.push({
+    name: "normalizeChapterTitle collapses The The",
+    pass: normalizeChapterTitle("The The frontier Reckoning") === "The frontier Reckoning",
+  });
+
+  // 2. Residue strip kills resumption bleed
+  const bleed = "_Resuming at chapter 2; 1 finished chapter(s) restored, not regenerated._\nReal prose continues here with enough body.";
+  const stripped = stripHarnessResidue(bleed);
+  cases.push({
+    name: "stripHarnessResidue removes resumption notice",
+    pass: stripped.removed.includes("resumption-notice") && !/_Resuming at chapter/.test(stripped.text),
+    detail: `removed=${stripped.removed.join(",")}`,
+  });
+
+  // 3. Full N-chapter commit simulation
+  const snapshot = createStorySnapshot(seed, chapterCount);
+  applySeedLocks(snapshot, {
+    ...DEFAULT_SEED_CONTROL,
+    locks: { setting: "Locked Estuary", coreConcept: "the sealed canister", theme: "debts inherit", motif: "mended cloth" },
+  });
+  cases.push({
+    name: "applySeedLocks mutates primary setting",
+    pass: snapshot.blueprint.primarySetting.name === "Locked Estuary",
+  });
+
+  let ledger = EMPTY_LEDGER;
+  let manuscript = "";
+  for (let i = 0; i < chapterCount; i++) {
+    const title = snapshot.blueprint.chapters[i]?.title || `Chapter ${i + 1}`;
+    const body = mockChapter(i + 1, title).replace(/^##.+\n\n/, "");
+    // Seed block must build without throw
+    const seedBlock = buildSeedDirectiveBlock(selectSeedDirectives(seed, i, DEFAULT_SEED_CONTROL), DEFAULT_SEED_CONTROL);
+    if (!seedBlock.includes("SEED DIRECTIVES")) {
+      cases.push({ name: `seed block ch${i + 1}`, pass: false, detail: "missing header" });
+    }
+    const block = `## ${title}\n\n${body}`;
+    manuscript = manuscript ? `${manuscript}\n\n${block}` : block;
+    const facts = extractChapterFacts({ chapter: i + 1, title, text: body, snapshot });
+    ledger = foldFacts(ledger, facts);
+    const v = truncationVerdict(body, 400);
+    if (v.truncated) {
+      cases.push({ name: `mock ch${i + 1} not truncated`, pass: false, detail: v.reason });
+    }
+  }
+  const parsed = parseChaptersFromText(manuscript);
+  cases.push({
+    name: `full ${chapterCount}-chapter commit parses to exactly ${chapterCount}`,
+    pass: parsed.length === chapterCount,
+    detail: `parsed=${parsed.length}`,
+  });
+  cases.push({
+    name: "ledger facts length equals chapter count",
+    pass: ledger.facts.length === chapterCount,
+    detail: `facts=${ledger.facts.length}`,
+  });
+  cases.push({
+    name: "ledger motifTotals bounded (≤120)",
+    pass: Object.keys(ledger.motifTotals).length <= 120,
+  });
+
+  // 4. Parse must ignore bleed-only preambles
+  const withBleed = `_SAGE fiction run started: ${chapterCount} chapters_\n\n${manuscript}`;
+  const cleaned = stripHarnessResidue(withBleed).text;
+  const reparsed = parseChaptersFromText(cleaned);
+  cases.push({
+    name: "parse after bleed-strip still yields full chapter count",
+    pass: reparsed.length === chapterCount,
+    detail: `parsed=${reparsed.length}`,
+  });
+
+  // 5. Revision unit honesty
+  const before = "The red door opened. A cold wind entered the hall.\n\nShe waited.";
+  const after = "The blue door opened. A cold wind entered the hall.\n\nShe waited by the stair.";
+  const units = classifyRevisionUnits(before, after);
+  cases.push({
+    name: "classifyRevisionUnits counts word-level change",
+    pass: units.word >= 1 || units.phrase >= 1 || units.sentence >= 1,
+    detail: JSON.stringify(units),
+  });
+  const decay = decayEditBudget(20, false);
+  cases.push({
+    name: "decayEditBudget prefers word over page",
+    pass: (decay.find((d) => d.unit === "word")?.maxEdits ?? 0) > (decay.find((d) => d.unit === "page")?.maxEdits ?? 0),
+  });
+
+  return { pass: cases.every((c) => c.pass), cases, ranAt: Date.now() };
+}