2sagaco48 1.0.0

package/src/fiction/diagnostics.ts

@@ -0,0 +1,208 @@
+/**
+ * FICTION DIAGNOSTICS & REMEDIATION ENGINE
+ * ---------------------------------------------------------------------------
+ * Evaluates manuscripts against the 15 Core Failure Modes (FM-02 through FM-16)
+ * both DETERMINISTICALLY (local regex, frequency checks, clock analysis) and
+ * via LLM-assisted deep diagnostic scans.
+ */
+import {
+  stripHarnessResidue,
+  normalizeChapterTitle,
+  RESIDUE_PATTERNS,
+} from "./continuity";
+
+export interface DiagnosticFinding {
+  code: string;
+  title: string;
+  severity: "critical" | "warning" | "info";
+  description: string;
+  count: number;
+  examples: string[];
+  suggestedPromptFix: string;
+  suggestedCodeFix: string;
+  autoFixAvailable: boolean;
+}
+
+export interface FullDiagnosticReport {
+  timestamp: number;
+  wordCount: number;
+  chapterCount: number;
+  findings: DiagnosticFinding[];
+  cleanlinessScore: number;
+  stasisRisk: "high" | "medium" | "low";
+  pacingRisk: "high" | "medium" | "low";
+}
+
+export function runDeterministicDiagnostics(manuscript: string): FullDiagnosticReport {
+  const text = manuscript || "";
+  const findings: DiagnosticFinding[] = [];
+  const words = (text.trim().match(/\S+/g) ?? []).length;
+  const chapterMatches = [...text.matchAll(/^(?:#{1,3}\s+|chapter\s+\d+|part\s+\d+).*$/gim)];
+  const chapterCount = chapterMatches.length;
+
+  // 1. FM-06: The The title bug
+  const doubleTheMatches = [...text.matchAll(/\b(?:The\s+The|A\s+A|An\s+An)\b/gi)].map((m) => m[0]);
+  if (doubleTheMatches.length > 0) {
+    findings.push({
+      code: "FM-06",
+      title: "Grammatical Concatenation Bug ('The The')",
+      severity: "critical",
+      description: "Chapter titles or headings contain duplicated definite or indefinite articles ('The The Reckoning').",
+      count: doubleTheMatches.length,
+      examples: doubleTheMatches.slice(0, 3),
+      suggestedPromptFix: "Specify: 'Format title as ## {N}. {Setting} without prepending an additional article if the setting already contains one.'",
+      suggestedCodeFix: "Apply `normalizeChapterTitle()` to all chapter headings before committing to manuscript.",
+      autoFixAvailable: true,
+    });
+  }
+
+  // 2. FM-07: Bracketed citation leakage
+  const residueHits: string[] = [];
+  for (const { id, re } of RESIDUE_PATTERNS) {
+    re.lastIndex = 0;
+    const ms = [...text.matchAll(re)].map((m) => m[0]);
+    if (ms.length > 0) residueHits.push(`${id} (${ms.length} hits: ${ms.slice(0, 2).join(", ")})`);
+  }
+  if (residueHits.length > 0) {
+    findings.push({
+      code: "FM-07",
+      title: "RAG / Grounding Citation Bracket Leakage",
+      severity: "critical",
+      description: "Bracketed citation or harness residue tokens ([Source 1], [CHECKSUM], [VERIFIED]) leaked into literary fiction prose.",
+      count: residueHits.length,
+      examples: residueHits.slice(0, 4),
+      suggestedPromptFix: "Append hard negative constraint: 'Never emit bracketed metadata of any kind: no [Source N], no [CHECKSUM], no status tags.'",
+      suggestedCodeFix: "Run `stripHarnessResidue(text)` before appending chapter output.",
+      autoFixAvailable: true,
+    });
+  }
+
+  // 3. FM-14: Instrument & Sensor Fetishism
+  const sensorMatches = [...text.matchAll(/\b\d[\d,.]*\s*(?:hertz|hz|decibels?|db|millimet(?:er|re)s?|mm|centimet(?:er|re)s?|cm|met(?:er|re)s?|kilomet(?:er|re)s?|km|milligauss|millirads?|millibars?|picoseconds?|milliseconds?|lux)\b/gi)].map((m) => m[0]);
+  if (sensorMatches.length > 10) {
+    findings.push({
+      code: "FM-14",
+      title: "Instrument & Sensor Fetishism as a Substitute for Voice",
+      severity: "warning",
+      description: "Excessive physical measurement readings (hertz, decibels, millibars) saturate the text in place of character action.",
+      count: sensorMatches.length,
+      examples: sensorMatches.slice(0, 5),
+      suggestedPromptFix: "Enforce craft budget: 'At most 4 numeric measurements with units in the entire chapter. Concrete specificity means named physical objects and consequences, not sensor telemetry.'",
+      suggestedCodeFix: "Set `DEFAULT_BUDGETS.measurements = 4` in `continuity.ts`.",
+      autoFixAvailable: false,
+    });
+  }
+
+  // 4. FM-15: Compulsive Currency Audits
+  const currencyMatches = [...text.matchAll(/\b\d[\d,.]*\s*(?:gold|silver|copper)?\s*(?:marks?|sovereigns?|crowns?|pieces?|francs?|credits?|shillings?)\b/gi)].map((m) => m[0]);
+  if (currencyMatches.length > 8) {
+    findings.push({
+      code: "FM-15",
+      title: "Compulsive Currency Audits (Bookkeeping Saturation)",
+      severity: "warning",
+      description: "Human interactions and narrative tension are constantly reduced to coin fees, fines, and ledger debits.",
+      count: currencyMatches.length,
+      examples: currencyMatches.slice(0, 4),
+      suggestedPromptFix: "Enforce craft budget: 'At most 2 explicit mentions of currency/fees. Emotional and philosophical stakes must not be converted into bookkeeping transactions.'",
+      suggestedCodeFix: "Set `DEFAULT_BUDGETS.currency = 2` in `continuity.ts`.",
+      autoFixAvailable: false,
+    });
+  }
+
+  // 5. FM-03: Procedural Deadlock / Stasis Verbs
+  const stasisVerbs = [...text.matchAll(/\b(measured|inspected|audited|checked|recorded|calibrated|reviewed|filed|signed)\b/gi)].map((m) => m[0].toLowerCase());
+  if (stasisVerbs.length > 15) {
+    findings.push({
+      code: "FM-03",
+      title: "Procedural Deadlock & Invariant Audit Activity",
+      severity: "critical",
+      description: "Repetitive procedural inspection verbs dominate scenes, causing characters to perform administrative tasks instead of narrative progression.",
+      count: stasisVerbs.length,
+      examples: stasisVerbs.slice(0, 6),
+      suggestedPromptFix: "Mandate: 'This chapter must change at least TWO of: physical location, who is present, what the protagonist knows, what the protagonist controls. An inspection or filing may not be the chapter's central action.'",
+      suggestedCodeFix: "Enable `enableFM03AntiStasis` in continuity governor.",
+      autoFixAvailable: false,
+    });
+  }
+
+  // 6. FM-04: Truncation Check
+  const trimmed = text.trim();
+  const unterminated = !!trimmed && !/[.!?"'”’)\]]$/.test(trimmed);
+  if (unterminated) {
+    findings.push({
+      code: "FM-04",
+      title: "Unterminated Sentence (Severe Truncation Risk)",
+      severity: "critical",
+      description: "The manuscript terminates abruptly on an incomplete sentence, indicating an output token cutoff or socket drop.",
+      count: 1,
+      examples: [trimmed.slice(-100)],
+      suggestedPromptFix: "Send continuation prompt: 'You are continuing ONE chapter of fiction cut off mid-delivery. Output ONLY the continuation prose starting from the final words.'",
+      suggestedCodeFix: "Enable auto-continuation loop in `story-engine.ts` with `truncationVerdict()`.",
+      autoFixAvailable: false,
+    });
+  }
+
+  // 7. FM-09: Climax Evasion / Administrative Anticlimax
+  const adminClimaxMatches = [...text.matchAll(/\b(?:petition is denied|court will issue an injunction|renewal of the records|matter of maintenance|dismissed as false|fine of \d+)\b/gi)].map((m) => m[0]);
+  if (adminClimaxMatches.length > 3) {
+    findings.push({
+      code: "FM-09",
+      title: "Climax Evasion via Administrative Trivialization",
+      severity: "warning",
+      description: "Climactic moments resolve through bureaucratic hearings, denied petitions, or paperwork rather than direct confrontations.",
+      count: adminClimaxMatches.length,
+      examples: adminClimaxMatches.slice(0, 3),
+      suggestedPromptFix: "Mandate: 'Stage the direct confrontation the book promised, in scene, with the antagonist present and acting. No hearing, memo, audit or petition may substitute for it.'",
+      suggestedCodeFix: "Enable Act Ladder obligations in `actObligation()` for chapters > 70% progress.",
+      autoFixAvailable: false,
+    });
+  }
+
+  const cleanlinessScore = Math.max(0, 100 - findings.filter((f) => f.severity === "critical").length * 25 - findings.filter((f) => f.severity === "warning").length * 10);
+  const stasisRisk = stasisVerbs.length > 20 ? "high" : stasisVerbs.length > 10 ? "medium" : "low";
+  const pacingRisk = findings.some((f) => f.code === "FM-03" || f.code === "FM-09" || f.code === "FM-04") ? "high" : "low";
+
+  return {
+    timestamp: Date.now(),
+    wordCount: words,
+    chapterCount,
+    findings,
+    cleanlinessScore,
+    stasisRisk,
+    pacingRisk,
+  };
+}
+
+/** Executes deterministic auto-fixes on text (strip residue, clean double-the titles). */
+export function applyDeterministicAutoFixes(manuscript: string): { cleanedText: string; fixesApplied: string[] } {
+  const fixes: string[] = [];
+  let out = manuscript;
+
+  // 1. Strip residue
+  const { text: residueCleaned, removed } = stripHarnessResidue(out);
+  if (removed.length > 0) {
+    out = residueCleaned;
+    fixes.push(`Removed ${removed.length} harness residue token(s): ${removed.join(", ")}`);
+  }
+
+  // 2. Normalize titles
+  const lines = out.split("\n");
+  let titleFixes = 0;
+  const newLines = lines.map((l) => {
+    if (/^(?:#{1,4}\s+|chapter\s+\d+)/i.test(l)) {
+      const normalized = normalizeChapterTitle(l);
+      if (normalized !== l) {
+        titleFixes++;
+        return normalized;
+      }
+    }
+    return l;
+  });
+
+  if (titleFixes > 0) {
+    out = newLines.join("\n");
+    fixes.push(`Normalized ${titleFixes} chapter title(s) to remove double-article glitches.`);
+  }
+
+  return { cleanedText: out, fixesApplied: fixes };
+}

package/src/fiction/diff.ts

@@ -0,0 +1,74 @@
+/**
+ * DIFF UTILITIES — highlighted difference computation between drafts.
+ * ---------------------------------------------------------------------------
+ * Computes word-level and sentence-level diff chunks:
+ *   - unchanged: text as is
+ *   - added: new text highlighted with <ins> / green styling
+ *   - removed: deleted text styled with <del> / red strikethrough
+ */
+
+export interface DiffChunk {
+  type: "unchanged" | "added" | "removed";
+  value: string;
+}
+
+export function computeWordDiff(oldStr: string, newStr: string): DiffChunk[] {
+  if (oldStr === newStr) return [{ type: "unchanged", value: oldStr }];
+  if (!oldStr) return [{ type: "added", value: newStr }];
+  if (!newStr) return [{ type: "removed", value: oldStr }];
+
+  const oldWords = oldStr.split(/(\s+)/);
+  const newWords = newStr.split(/(\s+)/);
+
+  // Simple and fast Myers-like common prefix / suffix with middle diff
+  let start = 0;
+  while (start < oldWords.length && start < newWords.length && oldWords[start] === newWords[start]) {
+    start++;
+  }
+
+  let oldEnd = oldWords.length - 1;
+  let newEnd = newWords.length - 1;
+  while (oldEnd >= start && newEnd >= start && oldWords[oldEnd] === newWords[newEnd]) {
+    oldEnd--;
+    newEnd--;
+  }
+
+  const chunks: DiffChunk[] = [];
+  const prefix = oldWords.slice(0, start).join("");
+  if (prefix) chunks.push({ type: "unchanged", value: prefix });
+
+  const removedMiddle = oldWords.slice(start, oldEnd + 1).join("");
+  const addedMiddle = newWords.slice(start, newEnd + 1).join("");
+
+  if (removedMiddle) chunks.push({ type: "removed", value: removedMiddle });
+  if (addedMiddle) chunks.push({ type: "added", value: addedMiddle });
+
+  const suffix = oldWords.slice(oldEnd + 1).join("");
+  if (suffix) chunks.push({ type: "unchanged", value: suffix });
+
+  return chunks;
+}
+
+/** Formats diff chunks as an HTML string suitable for rendering in the main chatbox. */
+export function formatDiffAsHtml(chunks: DiffChunk[]): string {
+  return chunks
+    .map((c) => {
+      if (c.type === "added") {
+        return `<mark class="diff-add" style="background-color: #d1fae5; color: #065f46; text-decoration: none; padding: 1px 3px; border-radius: 3px; font-weight: 500;">${escapeHtml(c.value)}</mark>`;
+      }
+      if (c.type === "removed") {
+        return `<del class="diff-del" style="background-color: #fee2e2; color: #991b1b; text-decoration: line-through; padding: 1px 3px; border-radius: 3px; opacity: 0.7;">${escapeHtml(c.value)}</del>`;
+      }
+      return escapeHtml(c.value);
+    })
+    .join("");
+}
+
+function escapeHtml(s: string): string {
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#039;");
+}

package/src/fiction/entity-state-machine.ts

@@ -0,0 +1,214 @@
+/**
+ * ENTITY STATE MACHINE (ESM) & TOPOGRAPHIC ROUTER (NIVE LAYER 2 & 3)
+ * ---------------------------------------------------------------------------
+ * Solves:
+ *   - Character resurrecting after somatic death (B.1.1)
+ *   - Ontological metamorphosis (e.g. unicorn-man chimera drift) (B.1.2)
+ *   - Biological sex and craft instability (A.1.2 / B.1.3)
+ *   - Modulo-4 cyclical setting ping-pong (A.2.1 / B.2.1)
+ *   - MacGuffin shape-shifting carousel (A.2.2)
+ */
+
+export type MortalityStatus = "ALIVE" | "DEAD" | "EXILED" | "CAPTURED" | "ERASED";
+
+export interface EntityStateRecord {
+  id: string;
+  name: string;
+  role: "protagonist" | "deuteragonist" | "antagonist" | "mentor" | "supporting";
+  species: "human" | "animal" | "hybrid" | "construct" | "spirit";
+  biologicalSex: "male" | "female" | "none" | "other";
+  mortalityStatus: MortalityStatus;
+  deathChapter: number | null;
+  deathCause?: string;
+  permanentWound: string;
+  lockedCraft: string;
+  inventory: string[];
+  currentLocationId: string;
+}
+
+export interface MacroObjectState {
+  name: string;
+  lockedForm: string; // e.g., "leather-bound vellum ledger in copper canister"
+  originChapter: number;
+  currentHolder: string;
+  status: "intact" | "damaged" | "destroyed" | "delivered";
+}
+
+export interface SpatialNode {
+  id: string;
+  name: string;
+  region: string;
+  neighbors: string[]; // Connected node IDs
+  transitHours: Record<string, number>; // Distance/time to neighbor
+  transitHazard?: string;
+}
+
+export class EntityStateMachine {
+  private entities: Map<string, EntityStateRecord> = new Map();
+  private macroObjects: Map<string, MacroObjectState> = new Map();
+  private worldNodes: Map<string, SpatialNode> = new Map();
+  private locationHistory: string[] = [];
+
+  constructor() {
+    this.initDefaultWorldGraph();
+  }
+
+  private initDefaultWorldGraph(): void {
+    const defaultNodes: SpatialNode[] = [
+      {
+        id: "borderland",
+        name: "The Limestone Borderland Promontory",
+        region: "Peripheral Sector 7",
+        neighbors: ["transit_tunnel", "salt_marshes"],
+        transitHours: { transit_tunnel: 3, salt_marshes: 5 },
+      },
+      {
+        id: "transit_tunnel",
+        name: "Merthe-Thares Sub-Surface Labyrinth",
+        region: "Intermediate Transit Conduit",
+        neighbors: ["borderland", "central_dystopia"],
+        transitHours: { borderland: 3, central_dystopia: 4 },
+        transitHazard: "humidity & limestone silt",
+      },
+      {
+        id: "central_dystopia",
+        name: "The Municipal Archive & Cryo Vaults",
+        region: "Urban Dystopia Core",
+        neighbors: ["transit_tunnel", "outer_village"],
+        transitHours: { transit_tunnel: 4, outer_village: 6 },
+      },
+      {
+        id: "outer_village",
+        name: "Tulkaaklang Cultivation Flats",
+        region: "Agrarian Periphery",
+        neighbors: ["central_dystopia", "salt_marshes"],
+        transitHours: { central_dystopia: 6, salt_marshes: 4 },
+      },
+      {
+        id: "salt_marshes",
+        name: "Keistlddsto Estuary & Lime Kilns",
+        region: "Coastal Shallows",
+        neighbors: ["borderland", "outer_village"],
+        transitHours: { borderland: 5, outer_village: 4 },
+        transitHazard: "shifting mud & tidal swell",
+      },
+    ];
+
+    for (const node of defaultNodes) {
+      this.worldNodes.set(node.id, node);
+    }
+  }
+
+  public registerEntity(record: EntityStateRecord): void {
+    this.entities.set(record.id.toLowerCase(), { ...record });
+  }
+
+  public registerMacroObject(obj: MacroObjectState): void {
+    this.macroObjects.set(obj.name.toLowerCase(), { ...obj });
+  }
+
+  public recordSomaticDeath(entityId: string, chapter: number, cause: string): void {
+    const ent = this.entities.get(entityId.toLowerCase());
+    if (ent) {
+      ent.mortalityStatus = "DEAD";
+      ent.deathChapter = chapter;
+      ent.deathCause = cause;
+    }
+  }
+
+  public isAlive(entityId: string): boolean {
+    const ent = this.entities.get(entityId.toLowerCase());
+    if (!ent) return true;
+    return ent.mortalityStatus === "ALIVE";
+  }
+
+  public getDeadEntities(): EntityStateRecord[] {
+    return Array.from(this.entities.values()).filter((e) => e.mortalityStatus === "DEAD");
+  }
+
+  public validateCandidateCast(candidateNames: string[], currentChapter: number): {
+    valid: string[];
+    banned: string[];
+    reasons: string[];
+  } {
+    const valid: string[] = [];
+    const banned: string[] = [];
+    const reasons: string[] = [];
+
+    for (const name of candidateNames) {
+      const ent = this.entities.get(name.toLowerCase());
+      if (ent && ent.mortalityStatus === "DEAD") {
+        banned.push(name);
+        reasons.push(
+          `Entity "${ent.name}" died in Chapter ${ent.deathChapter} (${ent.deathCause || "deceased"}). Cannot be cast in Chapter ${currentChapter}.`
+        );
+      } else {
+        valid.push(name);
+      }
+    }
+
+    return { valid, banned, reasons };
+  }
+
+  public stepLocation(newLocationName: string): {
+    validTransit: boolean;
+    transitNote?: string;
+    warning?: string;
+  } {
+    const locLower = newLocationName.toLowerCase();
+    this.locationHistory.push(locLower);
+
+    if (this.locationHistory.length >= 4) {
+      const recent4 = this.locationHistory.slice(-4);
+      const isPingPong =
+        recent4[0] === recent4[2] &&
+        recent4[1] === recent4[3] &&
+        recent4[0] !== recent4[1];
+
+      if (isPingPong) {
+        return {
+          validTransit: false,
+          warning: `Modulo-4 setting loop detected (${recent4[0]} <-> ${recent4[1]}). Enforcing directional transit out of loop.`,
+        };
+      }
+    }
+
+    return { validTransit: true };
+  }
+
+  /**
+   * Generates a deterministic State Invariant Block for injection into prompts.
+   */
+  public compileStateConstraintBlock(_currentChapter?: number): string {
+    const lines: string[] = [];
+    lines.push("=== ENTITY STATE MACHINE INVARIANTS (NIVE LAYER 2/3) ===");
+
+    const dead = this.getDeadEntities();
+    if (dead.length > 0) {
+      lines.push("BANNED ENTITIES (SOMATICALLY DECEASED — DO NOT RESURRECT):");
+      for (const d of dead) {
+        lines.push(`  - ${d.name} (${d.role}): Died in Chapter ${d.deathChapter}. Cannot speak, walk, or be in the room.`);
+      }
+    }
+
+    const alive = Array.from(this.entities.values()).filter((e) => e.mortalityStatus === "ALIVE");
+    if (alive.length > 0) {
+      lines.push("LOCKED ENTITY ATTRIBUTES (NO SEX SWAPPING, NO DRIFT):");
+      for (const a of alive) {
+        lines.push(
+          `  - ${a.name}: ${a.biologicalSex.toUpperCase()} ${a.species.toUpperCase()} (${a.lockedCraft}). Wound: "${a.permanentWound}".`
+        );
+      }
+    }
+
+    const objects = Array.from(this.macroObjects.values());
+    if (objects.length > 0) {
+      lines.push("MACGUFFIN STABILITY (NO SHAPE-SHIFTING):");
+      for (const obj of objects) {
+        lines.push(`  - ${obj.name}: Locked form is "${obj.lockedForm}". Held by ${obj.currentHolder}.`);
+      }
+    }
+
+    return lines.join("\n");
+  }
+}