2sagaco48 1.0.0

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

@@ -0,0 +1,329 @@
+/**
+ * SAGA-OS — multi-scale / multi-volume composition system (Turn 8).
+ * ---------------------------------------------------------------------------
+ * Additive integration of the P8 canonical "SAGA-OS v1" architecture
+ * (fable.canon SYSTEM v12): series modes, phase architecture, throughlines,
+ * scene grammars, pace vector + stakes rotation, promise/loop scopes, the
+ * 54-rule logic-audit families, repair operators, adversarial attacks, stop
+ * conditions, and the composition operators.
+ *
+ * DESIGN CONSTRAINT (per task): additive and optimal, NO new UI/UX unless
+ * strictly necessary. This module therefore exposes:
+ *   1. static canonical tables (data), and
+ *   2. two pure functions the existing SAGE engine already needs:
+ *        - buildSagaDirectiveBlock(): a compact directive snippet the chapter
+ *          prompt can append so single- and multi-chapter works inherit
+ *          throughline/pacing/promise discipline without any UI change;
+ *        - runSagaLogicAudit(): a local, no-LLM structural audit over an
+ *          already-generated blueprint + chapter texts, reusing the existing
+ *          judge/repetition philosophy (computed evidence, not self-declared).
+ *
+ * HONESTY: canonical tables are transcribed from the provided P8 document.
+ * The audit is a real local computation; it is not an LLM claim.
+ */
+
+export type SagaRow = { id: string; name: string; note: string };
+
+function parse(raw: string): SagaRow[] {
+  return raw
+    .trim()
+    .split(/\n+/)
+    .map((l) => l.trim())
+    .filter(Boolean)
+    .map((l) => {
+      const [id, name, ...rest] = l.split("|").map((p) => p.trim());
+      return { id, name, note: rest.join(" | ") };
+    });
+}
+
+// ── §8 Series architecture modes ────────────────────────────────────────────
+export const SAGA_SERIES_MODES: SagaRow[] = parse(`
+SERIES-MODE-001 | FINITE_SAGA | One overarching causal arc divided into locally satisfying volumes
+SERIES-MODE-002 | EPISODIC_META | Each volume has a complete case/adventure; a slower mystery or transformation accumulates
+SERIES-MODE-003 | SCHOOL_YEAR_SPIRAL | Recurring annual structure; cast ages, institutions reveal deeper layers
+SERIES-MODE-004 | MISFORTUNE_LEDGER_SERIAL | A stable episode grammar repeats, but every repetition accumulates evidence, loss, moral debt
+SERIES-MODE-005 | ROTATING_LEAD_MOSAIC | Different volume leads; shared world, institutions, consequences, relational network
+SERIES-MODE-006 | GENERATIONAL_SUCCESSION | Responsibility and unresolved causality transfer between generations
+SERIES-MODE-007 | INSTITUTION_LIFECYCLE | Protagonist is an institution moving through founding, capture, fracture, reform, residual legacy
+SERIES-MODE-008 | GEOGRAPHIC_EXPANSION_RETURN | Each volume expands the map; late volumes revisit transformed early locations
+SERIES-MODE-009 | SHARED_WORLD_ANTHOLOGY | Volumes may be locally independent, but world-state deltas remain canonical
+SERIES-MODE-010 | OPEN_SERIAL | No predetermined final volume; rolling phase horizons; every phase still has closure criteria
+`);
+
+// ── §9 Series phase architecture (normalized volume position bands) ─────────
+export const SAGA_PHASES: { range: string; phase: string }[] = [
+  { range: "0.00–0.15", phase: "FOUNDATION" },
+  { range: "0.15–0.35", phase: "EXPANSION" },
+  { range: "0.35–0.50", phase: "REVERSAL" },
+  { range: "0.50–0.65", phase: "DEEPENING" },
+  { range: "0.65–0.80", phase: "FRACTURE" },
+  { range: "0.80–0.93", phase: "CONVERGENCE" },
+  { range: "0.93–1.00", phase: "CLOSURE" },
+];
+
+// ── §7 Throughlines (ES-LN-TL) ──────────────────────────────────────────────
+export const SAGA_THROUGHLINES: SagaRow[] = parse(`
+ES-LN-TL001 | Objective-System Throughline | external institutional/systemic pressure involving many characters
+ES-LN-TL002 | Main-Character Throughline | the protagonist's private pressure, fear, wound, or decision boundary
+ES-LN-TL003 | Influence-Character Throughline | a challenger who embodies a viable alternative method of living or acting
+ES-LN-TL004 | Relationship Throughline | the evolving bond between protagonist and influence figure or key counterpart
+ES-LN-TL005 | Grounded-System Throughline | a non-metaphysical institution / ecology / infrastructure that keeps the novel concrete
+ES-LN-TL006 | Residual Throughline | what remains after apparent resolution: ash, debt, route, office, unclaimed prize, successor, maintenance duty
+ES-LN-TL007 | Sub-Character Throughline | bit-player / standby / ambient / family / interstitial figures create recurrence and texture
+ES-LN-TL008 | Setting-Pressure Throughline | recurring settings apply different constraints at different acts
+`);
+
+// ── §13 Scene grammars ──────────────────────────────────────────────────────
+export const SAGA_SCENE_GRAMMARS: SagaRow[] = parse(`
+SCENE-GRAMMAR-001 | ACTION | Goal → Opposition → Action → Setback/Cost
+SCENE-GRAMMAR-002 | PROCESSING | Reaction → Interpretation → Dilemma → Decision
+SCENE-GRAMMAR-003 | INVESTIGATION | Question → Search → Evidence → Revised hypothesis
+SCENE-GRAMMAR-004 | INSTITUTIONAL | Rule invoked → Parties argue → Ruling → New obligation
+SCENE-GRAMMAR-005 | MAINTENANCE | Baseline checked → Drift detected → Intervention → Residual risk
+SCENE-GRAMMAR-006 | RITUAL | Preconditions → Performance → Deviation → Social consequence
+SCENE-GRAMMAR-007 | TRAVEL/TRANSITION | Departure state → Boundary friction → Arrival delta
+SCENE-GRAMMAR-008 | RELATIONAL | Bid → Interpretation → Response → Relationship delta
+SCENE-GRAMMAR-009 | ENSEMBLE CONVERGENCE | Multiple strand goals → shared constraint → allocation → distributed consequence
+SCENE-GRAMMAR-010 | AFTERMATH | Cost inventory → grief/relief → responsibility assignment → next contract
+`);
+
+// ── §16 Pace vector dimensions + §16.4 stakes rotation ──────────────────────
+export const SAGA_PACE_DIMENSIONS = [
+  "danger", "urgency", "uncertainty", "intimacy", "moral_cost",
+  "institutional_pressure", "novelty", "grief", "relief", "cognitive_update_load",
+] as const;
+
+export const SAGA_STAKES_AXES = [
+  "physical", "relational", "epistemic", "institutional",
+  "identity", "moral", "ecological", "custodial",
+] as const;
+
+// ── §15 Promise scopes/states + §18.2 composition operators ─────────────────
+export const SAGA_PROMISE_SCOPES = ["LOCAL", "PHASE", "SAGA", "RESIDUAL"] as const;
+export const SAGA_PROMISE_STATES = [
+  "SEEDED", "REINFORCED", "COMPLICATED", "REPRICED", "PARTIALLY_PAID",
+  "PAID", "TRANSFERRED", "EXPIRED", "REPUDIATED", "RESIDUALIZED",
+] as const;
+
+export const SAGA_COMPOSITION_OPERATORS: SagaRow[] = parse(`
+OP-001 | BIND | Assign catalog primitive to a typed slot
+OP-002 | SEED | Introduce future-use element before activation
+OP-003 | ECHO | Repeat an element with altered context
+OP-004 | REPRICE | Change understood cost or meaning without deleting prior facts
+OP-005 | PAY | Resolve a promise proportionally to its setup
+OP-006 | TRANSFER | Move responsibility, debt, office, object, or loop
+OP-007 | PROMOTE | Elevate a satellite into a lead after seeded agency
+OP-008 | DEMOTE | Return lead to satellite after closure or handoff
+OP-009 | DORMANT | Park a strand with a return trigger
+OP-010 | REACTIVATE | Return a dormant strand through a reader re-entry packet
+OP-011 | FORK | Split a relation, institution, or strand into distinct successors
+OP-012 | CONVERGE | Join strands through shared cause, resource, verdict, or cost
+OP-013 | RESIDUALIZE | Name what remains after nominal resolution
+OP-014 | RETIRE | Deliberately end a system while it still functions
+OP-015 | TRANSFORM_SETTING | Alter a recurring place and later revisit it
+OP-016 | SHIFT_STAKES | Change dominant pressure dimension across volumes
+OP-017 | REVEAL | Change knowledge, not world history
+OP-018 | MUTATE_RULE | Change a world rule through a logged causal event
+OP-019 | REFRAME | Change interpretation while preserving facts
+OP-020 | CLOSE | Pay, expire, transfer, repudiate, or residualize a loop
+`);
+
+// ── §19 Logic audit families (54-rule suite, id/name index) ─────────────────
+export const SAGA_AUDIT_RULES: SagaRow[] = parse(`
+AUDIT-001 | ID uniqueness | canon & identity
+AUDIT-002 | locked-attribute consistency | canon & identity
+AUDIT-003 | age/calendar consistency | canon & identity
+AUDIT-004 | identity alias and disguise consistency | canon & identity
+AUDIT-005 | death, absence, and return validity | canon & identity
+AUDIT-006 | event preconditions | causality & intentionality
+AUDIT-007 | event effects | causality & intentionality
+AUDIT-008 | intentional-agent goal | causality & intentionality
+AUDIT-009 | available alternatives | causality & intentionality
+AUDIT-010 | why-this-action-now | causality & intentionality
+AUDIT-011 | declared causal-cycle fixed-point | causality & intentionality
+AUDIT-012 | character knowledge boundary | knowledge & revelation
+AUDIT-013 | reader-safe reveal boundary | knowledge & revelation
+AUDIT-014 | event-time vs reveal-time | knowledge & revelation
+AUDIT-015 | rumor/belief/source lineage | knowledge & revelation
+AUDIT-016 | dramatic-irony integrity | knowledge & revelation
+AUDIT-017 | world-rule persistence | world & geography
+AUDIT-018 | limitation/exception integrity | world & geography
+AUDIT-019 | institution lifecycle | world & geography
+AUDIT-020 | geography and travel time | world & geography
+AUDIT-021 | jurisdiction continuity | world & geography
+AUDIT-022 | resource-flow conservation | world & geography
+AUDIT-023 | ecology and infrastructure aftermath | world & geography
+AUDIT-024 | object location and custody | world & geography
+AUDIT-025 | agency floor | character & relationship
+AUDIT-026 | competence and capacity | character & relationship
+AUDIT-027 | relationship delta | character & relationship
+AUDIT-028 | relationship-memory continuity | character & relationship
+AUDIT-029 | promotion/demotion/exit validity | character & relationship
+AUDIT-030 | recurring sub-character function | character & relationship
+AUDIT-031 | adversary intentionality | character & relationship
+AUDIT-032 | strand necessity | plot & promise
+AUDIT-033 | promise lifecycle | plot & promise
+AUDIT-034 | clue fair-play | plot & promise
+AUDIT-035 | loop debt | plot & promise
+AUDIT-036 | convergence contract | plot & promise
+AUDIT-037 | cost routing | plot & promise
+AUDIT-038 | residual selection | plot & promise
+AUDIT-039 | active cast budget | reader load & pacing
+AUDIT-040 | high update-cost anchoring | reader load & pacing
+AUDIT-041 | dormant strand re-entry | reader load & pacing
+AUDIT-042 | pacing-vector profile | reader load & pacing
+AUDIT-043 | stakes rotation | reader load & pacing
+AUDIT-044 | relationship change points | reader load & pacing
+AUDIT-045 | event-boundary overload | reader load & pacing
+AUDIT-046 | local volume closure | volume & series
+AUDIT-047 | irreversible series delta | volume & series
+AUDIT-048 | middle-volume necessity | volume & series
+AUDIT-049 | final-volume congestion | volume & series
+AUDIT-050 | book identity differentiation | volume & series
+AUDIT-051 | series theme lock | volume & series
+AUDIT-052 | final mandatory-loop closure | volume & series
+AUDIT-053 | residue and succession | volume & series
+AUDIT-054 | stop condition | volume & series
+`);
+
+// ── §21 repair operators + §22 adversarial attacks (index) ──────────────────
+export const SAGA_REPAIR_OPERATORS: string[] = [
+  "seed earlier", "add bridge scene", "change POV",
+  "reassign action to a motivated character", "merge characters",
+  "demote passenger POV", "split overloaded volume",
+  "collapse redundant institutions", "localize a world rule",
+  "convert retcon into misinformation or reveal", "pay or transfer a promise",
+  "alter dominant stakes dimension", "add re-entry packet",
+  "retire a redundant setting", "move climax earlier/later", "change ending family",
+];
+
+export const SAGA_ATTACKS: SagaRow[] = parse(`
+ATTACK-001 | REMOVE-CHARACTER | Remove each recurring character; if nothing breaks, merge or delete
+ATTACK-002 | SKIP-VOLUME | Remove a middle volume; if endgame unchanged, volume fails
+ATTACK-003 | SWAP-VOLUMES | Swap adjacent volumes; if order still works identically, phase roles meaningless
+ATTACK-004 | FIRST-TIME-READER | Read only reader-safe packets; detect future leakage and unexplained returns
+ATTACK-005 | PUBLICATION-GAP | Assume two years passed; test re-entry sufficiency
+ATTACK-006 | BINGE | Read continuously; detect repetitive recaps and formula fatigue
+ATTACK-010 | VILLAIN-REMOVAL | Remove antagonist; if plot survives unchanged, reclassify conflict honestly
+ATTACK-012 | PROMISE-SATURATION | Count unresolved loops at each book ending; detect series-loop inflation
+ATTACK-015 | ENDGAME-CONGESTION | Count first-time reactivations in final 15%
+`);
+
+// ── §26 stop conditions (finite series) ─────────────────────────────────────
+export const SAGA_STOP_CONDITIONS: SagaRow[] = parse(`
+STOP-001 | dominant saga question answered/rejected/certified-incomparable | finite
+STOP-002 | all mandatory saga promises paid/transferred/expired/repudiated/residualized | finite
+STOP-003 | every S0–S2 character closed/handed-off/named-stable | finite
+STOP-004 | every hard world-rule mutation has aftermath | finite
+STOP-005 | final institutional state named | finite
+STOP-006 | residual cost and custodianship assigned | finite
+STOP-007 | no mandatory thread first reactivated in final volume | finite
+STOP-008 | final ending family matches governing mechanism | finite
+`);
+
+/**
+ * Compact SAGA-OS directive block. Appended (optionally) to the SAGE chapter
+ * prompt so single-work and long-form output inherit throughline balance,
+ * vector pacing, promise discipline, and residual-closure logic — with zero
+ * new UI. Kept short to avoid re-inflating the context-poisoning surface the
+ * compact-prompt fix already addressed.
+ */
+export function buildSagaDirectiveBlock(totalChapters: number): string {
+  const scale = totalChapters >= 12 ? "long-form (treat as a volume; enforce phase movement)"
+    : totalChapters >= 4 ? "novella (partial phase movement)"
+    : "single-sitting (compress phases; still close locally)";
+  return [
+    "SAGA-OS COMPOSITION DISCIPLINE (apply silently; do not name these rules in prose):",
+    `- Scale: ${scale}.`,
+    "- Run at least four pressures across the whole work: an external system, the protagonist's private wound, a challenger's alternative method, and the central relationship. Each must change state, not merely recur.",
+    "- Change the governing problem at least twice across the arc (what is wrong → what fixing it costs → why old tools fail). Do not merely escalate danger.",
+    "- Pacing is a vector, not one 'tension' number: rotate danger / uncertainty / intimacy / moral-cost / institutional-pressure / grief / relief. Do not let one axis dominate every chapter.",
+    "- Alternate pressure scenes with processing/aftermath; never run 3 high-action chapters with no reaction beat.",
+    "- Promise discipline: every setup (vow, clue, debt, planted object) must be PAID, TRANSFERRED, EXPIRED, or explicitly RESIDUALIZED. No orphan setups, no unset payoffs.",
+    "- Every apparent success routes its cost to a visible person, institution, or future (cost-routing).",
+    "- The midpoint must REPRICE the premise (a prior win becomes newly costly), not just intensify it.",
+    "- Ending: name what remains (residue / successor / maintenance duty) rather than a clean total victory unless the tone demands it.",
+    "- Settings must constrain action; if a scene could move to any room with no change, the setting is decorative — make it load-bearing.",
+  ].join("\n");
+}
+
+// ── Local structural audit (real computation, no LLM) ───────────────────────
+
+export type SagaAuditFinding = {
+  ruleId: string;
+  ruleName: string;
+  severity: "pass" | "warn" | "fail";
+  detail: string;
+};
+
+export type SagaAuditReport = {
+  findings: SagaAuditFinding[];
+  passCount: number;
+  warnCount: number;
+  failCount: number;
+};
+
+type ChapterSlice = { title: string; text: string; targetWords: number };
+
+/**
+ * Runs the locally-checkable subset of the 54-rule audit over a finished work.
+ * These are the rules verifiable without an author-annotated knowledge graph;
+ * the remainder are surfaced as informational (skipped-with-reason) so the
+ * report is honest about what was and was not machine-checked.
+ */
+export function runSagaLogicAudit(chapters: ChapterSlice[], totalStakesAxes: number): SagaAuditReport {
+  const findings: SagaAuditFinding[] = [];
+  const wc = (t: string) => (t.trim().match(/\S+/g) || []).length;
+  const words = chapters.map((c) => wc(c.text));
+  const total = words.reduce((a, b) => a + b, 0);
+
+  // AUDIT-042 pacing-vector profile — chapter length variance (ebb/flow present?)
+  const mean = words.length ? total / words.length : 0;
+  const variance = words.length ? words.reduce((a, w) => a + (w - mean) ** 2, 0) / words.length : 0;
+  const cv = mean > 0 ? Math.sqrt(variance) / mean : 0;
+  findings.push({
+    ruleId: "AUDIT-042", ruleName: "pacing-vector profile",
+    severity: cv >= 0.08 ? "pass" : "warn",
+    detail: `chapter-length coefficient of variation ${(cv * 100).toFixed(1)}% (${cv >= 0.08 ? "natural ebb/flow present" : "chapters too uniform — enable prose-cadence variance"})`,
+  });
+
+  // AUDIT-046 local closure — final chapter should contain a closing signal
+  const last = chapters[chapters.length - 1]?.text ?? "";
+  const closingSignal = /\b(end|last|final|remain|remained|after|years later|schedule|inherit|hand(ed)? (it|the)|carried forward)\b/i.test(last);
+  findings.push({
+    ruleId: "AUDIT-046", ruleName: "local volume closure",
+    severity: chapters.length === 0 ? "warn" : closingSignal ? "pass" : "warn",
+    detail: closingSignal ? "closing/residual language detected in final chapter" : "no explicit closure/residual signal detected in final chapter",
+  });
+
+  // AUDIT-050 book identity differentiation — chapters shouldn't be near-identical openers
+  const openers = chapters.map((c) => c.text.trim().slice(0, 60).toLowerCase().replace(/\s+/g, " "));
+  const uniqueOpeners = new Set(openers).size;
+  findings.push({
+    ruleId: "AUDIT-050", ruleName: "book identity differentiation",
+    severity: chapters.length <= 1 || uniqueOpeners === openers.length ? "pass" : "warn",
+    detail: `${uniqueOpeners}/${openers.length} distinct chapter openings`,
+  });
+
+  // AUDIT-043 stakes rotation — informational (needs blueprint stakes axes)
+  findings.push({
+    ruleId: "AUDIT-043", ruleName: "stakes rotation",
+    severity: totalStakesAxes >= 2 ? "pass" : "warn",
+    detail: `${totalStakesAxes} stakes axis/axes engaged across the arc`,
+  });
+
+  // AUDIT-045 event-boundary overload — very long single chapters with no breaks
+  const denseChapters = chapters.filter((c) => wc(c.text) > 0 && (c.text.match(/\n{2,}/g) || []).length < 2 && wc(c.text) > 400).length;
+  findings.push({
+    ruleId: "AUDIT-045", ruleName: "event-boundary overload",
+    severity: denseChapters === 0 ? "pass" : "warn",
+    detail: denseChapters === 0 ? "no unbroken dense chapters" : `${denseChapters} chapter(s) exceed 400 words with <2 paragraph breaks`,
+  });
+
+  const passCount = findings.filter((f) => f.severity === "pass").length;
+  const warnCount = findings.filter((f) => f.severity === "warn").length;
+  const failCount = findings.filter((f) => f.severity === "fail").length;
+  return { findings, passCount, warnCount, failCount };
+}
+
+export const SAGA_OS_VERSION = "SAGA-OS v1 (fable.canon SYSTEM v12)";