ava-langgraph-narrative-intelligence 0.1.0

package/dist/graphs/index.cjs

@@ -0,0 +1,1511 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/graphs/index.ts
+var graphs_exports = {};
+__export(graphs_exports, {
+  EventType: () => EventType,
+  GapSeverity: () => GapSeverity,
+  GapType: () => GapType,
+  NarrativeCoherenceEngine: () => NarrativeCoherenceEngine,
+  RoutingTarget: () => RoutingTarget,
+  ThreeUniverseProcessor: () => ThreeUniverseProcessor,
+  analyzeCeremonyPerspective: () => analyzeCeremonyPerspective,
+  analyzeEngineerPerspective: () => analyzeEngineerPerspective,
+  analyzeStoryEnginePerspective: () => analyzeStoryEnginePerspective,
+  ceremonyIntentKeywords: () => ceremonyIntentKeywords,
+  createCoherenceScore: () => createCoherenceScore,
+  createComponentScore: () => createComponentScore,
+  createGap: () => createGap,
+  createTrinityAssessment: () => createTrinityAssessment,
+  engineerIntentKeywords: () => engineerIntentKeywords,
+  storyEngineIntentKeywords: () => storyEngineIntentKeywords,
+  synthesizePerspectives: () => synthesizePerspectives
+});
+module.exports = __toCommonJS(graphs_exports);
+
+// src/schemas/unified_state_bridge.ts
+function createUniversePerspective(universe, intent, confidence, options = {}) {
+  return {
+    universe,
+    intent,
+    confidence,
+    suggestedFlows: options.suggestedFlows ?? [],
+    context: options.context ?? {}
+  };
+}
+function createThreeUniverseAnalysis(engineer, ceremony, storyEngine, leadUniverse, coherenceScore) {
+  return {
+    engineer,
+    ceremony,
+    storyEngine,
+    leadUniverse,
+    coherenceScore,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createStoryBeat(id, sequence, content, narrativeFunction, act, options = {}) {
+  return {
+    id,
+    sequence,
+    content,
+    narrativeFunction,
+    act,
+    universeAnalysis: options.universeAnalysis,
+    leadUniverse: options.leadUniverse ?? "story_engine" /* STORY_ENGINE */,
+    emotionalTone: options.emotionalTone ?? "neutral",
+    thematicTags: options.thematicTags ?? [],
+    characterId: options.characterId,
+    characterArcImpact: options.characterArcImpact ?? 0,
+    source: options.source ?? "generator",
+    sourceEventId: options.sourceEventId,
+    timestamp: options.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+    enrichmentsApplied: options.enrichmentsApplied ?? [],
+    qualityScore: options.qualityScore ?? 0.5
+  };
+}
+
+// src/graphs/three_universe_processor.ts
+var EventType = /* @__PURE__ */ ((EventType2) => {
+  EventType2["GITHUB_PUSH"] = "github.push";
+  EventType2["GITHUB_ISSUE"] = "github.issue";
+  EventType2["GITHUB_PR"] = "github.pull_request";
+  EventType2["GITHUB_COMMENT"] = "github.comment";
+  EventType2["GITHUB_REVIEW"] = "github.review";
+  EventType2["USER_INPUT"] = "user.input";
+  EventType2["AGENT_ACTION"] = "agent.action";
+  EventType2["SYSTEM_EVENT"] = "system.event";
+  return EventType2;
+})(EventType || {});
+function engineerIntentKeywords() {
+  return {
+    feature_implementation: [
+      "feat:",
+      "feature",
+      "add",
+      "implement",
+      "create",
+      "new"
+    ],
+    bug_fix: ["fix:", "bug", "hotfix", "patch", "resolve", "correct"],
+    refactor: ["refactor", "refact:", "cleanup", "restructure", "reorganize"],
+    documentation: ["docs:", "doc:", "documentation", "readme", "comment"],
+    testing: ["test:", "tests:", "testing", "spec", "coverage"],
+    dependency: ["deps:", "dependency", "upgrade", "update", "bump"],
+    configuration: ["config:", "configure", "settings", "env"],
+    performance: ["perf:", "performance", "optimize", "speed", "cache"],
+    security: ["security", "sec:", "vulnerability", "auth", "permission"],
+    ci_cd: ["ci:", "cd:", "pipeline", "workflow", "build"]
+  };
+}
+function analyzeEngineerPerspective(state) {
+  const event = state.event;
+  const eventType = state.eventType;
+  let content = "";
+  const payload = event.payload;
+  if (payload) {
+    const commits = payload.commits;
+    if (commits) {
+      content = commits.map((c) => c.message || "").join(" ");
+    } else if (payload.issue) {
+      const issue = payload.issue;
+      content = (issue.title || "") + " " + (issue.body || "");
+    } else if (payload.pull_request) {
+      const pr = payload.pull_request;
+      content = (pr.title || "") + " " + (pr.body || "");
+    }
+  } else if (event.content) {
+    content = event.content;
+  }
+  const contentLower = content.toLowerCase();
+  const keywords = engineerIntentKeywords();
+  const intentScores = {};
+  for (const [intent2, terms] of Object.entries(keywords)) {
+    const score = terms.filter(
+      (term) => contentLower.includes(term.toLowerCase())
+    ).length;
+    if (score > 0) {
+      intentScores[intent2] = score / terms.length;
+    }
+  }
+  let intent;
+  let confidence;
+  if (Object.keys(intentScores).length > 0) {
+    intent = Object.entries(intentScores).reduce(
+      (a, b) => a[1] > b[1] ? a : b
+    )[0];
+    confidence = Math.min(0.95, 0.6 + intentScores[intent] * 0.4);
+  } else {
+    intent = "maintenance";
+    confidence = 0.5;
+  }
+  const flowMap = {
+    feature_implementation: [
+      "code_review",
+      "integration_test",
+      "documentation_update"
+    ],
+    bug_fix: ["regression_test", "root_cause_analysis", "changelog_update"],
+    refactor: ["architecture_review", "performance_test", "code_quality"],
+    documentation: ["doc_review", "example_validation"],
+    testing: ["coverage_analysis", "test_quality_review"],
+    dependency: ["security_scan", "compatibility_test"],
+    configuration: ["validation_test", "rollback_plan"],
+    performance: ["benchmark", "profiling", "optimization_review"],
+    security: ["security_audit", "penetration_test", "credential_scan"],
+    ci_cd: ["pipeline_validation", "deployment_test"],
+    maintenance: ["standard_ci"]
+  };
+  const suggestedFlows = flowMap[intent] || ["standard_ci"];
+  const context = {
+    detectedKeywords: Object.entries(intentScores).filter(([, v]) => v > 0).map(([k]) => k),
+    contentLength: content.length,
+    eventType,
+    technicalScope: determineTechnicalScope(content, event),
+    estimatedComplexity: estimateComplexity(content, event)
+  };
+  const perspective = createUniversePerspective(
+    "engineer" /* ENGINEER */,
+    intent,
+    confidence,
+    { suggestedFlows, context }
+  );
+  return { ...state, engineerPerspective: perspective };
+}
+function determineTechnicalScope(content, _event) {
+  const contentLower = content.toLowerCase();
+  if (["api", "endpoint", "route"].some((kw) => contentLower.includes(kw))) {
+    return "api_layer";
+  }
+  if (["database", "schema", "migration"].some((kw) => contentLower.includes(kw))) {
+    return "data_layer";
+  }
+  if (["ui", "component", "frontend"].some((kw) => contentLower.includes(kw))) {
+    return "presentation_layer";
+  }
+  if (["test", "spec"].some((kw) => contentLower.includes(kw))) {
+    return "testing";
+  }
+  if (["config", "env", "settings"].some((kw) => contentLower.includes(kw))) {
+    return "configuration";
+  }
+  return "general";
+}
+function estimateComplexity(content, event) {
+  const payload = event.payload;
+  if (payload) {
+    const commits = payload.commits;
+    if (commits) {
+      if (commits.length > 5) return "high";
+      if (commits.length > 2) return "medium";
+    }
+  }
+  if (content.length > 500) return "high";
+  if (content.length > 100) return "medium";
+  return "low";
+}
+function ceremonyIntentKeywords() {
+  return {
+    co_creation: ["we", "together", "team", "pair", "collaborate", "co-author"],
+    gratitude_expression: [
+      "thanks",
+      "thank you",
+      "grateful",
+      "appreciate",
+      "credit"
+    ],
+    witnessing: ["witness", "observe", "acknowledge", "see", "recognize"],
+    sacred_pause: ["pause", "reflect", "consider", "contemplate", "breathe"],
+    relationship_building: [
+      "connect",
+      "relationship",
+      "community",
+      "support"
+    ],
+    healing: ["heal", "restore", "repair", "reconcile", "mend"],
+    celebration: [
+      "celebrate",
+      "milestone",
+      "achievement",
+      "success",
+      "complete"
+    ],
+    offering: ["offer", "gift", "contribute", "share", "give"]
+  };
+}
+function analyzeCeremonyPerspective(state) {
+  const event = state.event;
+  const contributors = extractContributors(event);
+  const content = extractContent(event);
+  const contentLower = content.toLowerCase();
+  const keywords = ceremonyIntentKeywords();
+  const intentScores = {};
+  for (const [intent2, terms] of Object.entries(keywords)) {
+    const score = terms.filter((term) => contentLower.includes(term)).length;
+    if (score > 0) {
+      intentScores[intent2] = score / terms.length;
+    }
+  }
+  if (contributors.length > 1) {
+    intentScores.co_creation = (intentScores.co_creation || 0) + 0.5;
+  }
+  let intent;
+  let confidence;
+  if (Object.keys(intentScores).length > 0) {
+    intent = Object.entries(intentScores).reduce(
+      (a, b) => a[1] > b[1] ? a : b
+    )[0];
+    confidence = Math.min(0.95, 0.5 + intentScores[intent] * 0.4);
+  } else {
+    intent = "individual_offering";
+    confidence = 0.6;
+  }
+  const flowMap = {
+    co_creation: ["witness_collaboration", "honor_contributions", "amplify_voices"],
+    gratitude_expression: [
+      "amplify_acknowledgment",
+      "record_connection",
+      "reciprocity_check"
+    ],
+    witnessing: ["hold_space", "reflect_back", "presence"],
+    sacred_pause: ["create_silence", "contemplation_prompt", "breathing_space"],
+    relationship_building: [
+      "map_connections",
+      "strengthen_ties",
+      "introduce_support"
+    ],
+    healing: ["compassion_response", "restoration_path", "forgiveness_space"],
+    celebration: ["amplify_joy", "community_acknowledgment", "gratitude_circle"],
+    offering: ["receive_gracefully", "honor_gift", "share_forward"],
+    individual_offering: [
+      "witness_work",
+      "hold_space",
+      "gentle_acknowledgment"
+    ]
+  };
+  const suggestedFlows = flowMap[intent] || ["witness_work", "hold_space"];
+  const context = {
+    contributors,
+    isCollaborative: contributors.length > 1,
+    senderEnergy: assessEnergy(content),
+    witnessingNeeded: needsWitnessing(content, event),
+    relationshipDepth: assessRelationshipDepth(contributors, event),
+    sevenGenerationRelevance: assessLongTermImpact(content, event)
+  };
+  const perspective = createUniversePerspective(
+    "ceremony" /* CEREMONY */,
+    intent,
+    confidence,
+    { suggestedFlows, context }
+  );
+  return { ...state, ceremonyPerspective: perspective };
+}
+function extractContributors(event) {
+  const contributors = [];
+  if (event.sender) {
+    contributors.push(event.sender);
+  }
+  const payload = event.payload;
+  if (payload) {
+    const commits = payload.commits;
+    if (commits) {
+      for (const commit of commits) {
+        const author = commit.author?.name;
+        if (author && !contributors.includes(author)) {
+          contributors.push(author);
+        }
+      }
+    }
+    const issue = payload.issue;
+    if (issue) {
+      const user = issue.user;
+      if (user?.login && !contributors.includes(user.login)) {
+        contributors.push(user.login);
+      }
+    }
+    const pr = payload.pull_request;
+    if (pr) {
+      const user = pr.user;
+      if (user?.login && !contributors.includes(user.login)) {
+        contributors.push(user.login);
+      }
+    }
+  }
+  return contributors.length > 0 ? contributors : ["unknown"];
+}
+function extractContent(event) {
+  if (event.content) {
+    return event.content;
+  }
+  const payload = event.payload;
+  if (payload) {
+    const parts = [];
+    const commits = payload.commits;
+    if (commits) {
+      parts.push(...commits.map((c) => c.message || ""));
+    }
+    const issue = payload.issue;
+    if (issue) {
+      parts.push(issue.title || "");
+      parts.push(issue.body || "");
+    }
+    const pr = payload.pull_request;
+    if (pr) {
+      parts.push(pr.title || "");
+      parts.push(pr.body || "");
+    }
+    const comment = payload.comment;
+    if (comment) {
+      parts.push(comment.body || "");
+    }
+    return parts.filter(Boolean).join(" ");
+  }
+  return "";
+}
+function assessEnergy(content) {
+  const contentLower = content.toLowerCase();
+  if (["urgent", "critical", "asap", "emergency"].some(
+    (w) => contentLower.includes(w)
+  )) {
+    return "urgent_flow";
+  }
+  if (["excited", "happy", "great", "awesome"].some(
+    (w) => contentLower.includes(w)
+  )) {
+    return "joyful_flow";
+  }
+  if (["stuck", "blocked", "help", "issue"].some(
+    (w) => contentLower.includes(w)
+  )) {
+    return "seeking_support";
+  }
+  if (["thoughtful", "consider", "reflect"].some(
+    (w) => contentLower.includes(w)
+  )) {
+    return "contemplative_flow";
+  }
+  return "steady_flow";
+}
+function needsWitnessing(content, _event) {
+  const contentLower = content.toLowerCase();
+  if (["first", "new", "trying", "learning", "help"].some(
+    (w) => contentLower.includes(w)
+  )) {
+    return true;
+  }
+  if (["complete", "achieve", "milestone", "done"].some(
+    (w) => contentLower.includes(w)
+  )) {
+    return true;
+  }
+  return false;
+}
+function assessRelationshipDepth(contributors, _event) {
+  if (contributors.length > 2) return "community";
+  if (contributors.length > 1) return "pair";
+  return "individual";
+}
+function assessLongTermImpact(content, _event) {
+  const contentLower = content.toLowerCase();
+  let score = 0.3;
+  if (["architecture", "foundation", "core", "framework"].some(
+    (w) => contentLower.includes(w)
+  )) {
+    score += 0.3;
+  }
+  if (["document", "guide", "tutorial", "example"].some(
+    (w) => contentLower.includes(w)
+  )) {
+    score += 0.2;
+  }
+  if (["breaking", "migration", "deprecate"].some(
+    (w) => contentLower.includes(w)
+  )) {
+    score += 0.2;
+  }
+  return Math.min(1, score);
+}
+function storyEngineIntentKeywords() {
+  return {
+    inciting_incident: ["init", "start", "begin", "new", "first", "introduce"],
+    rising_action: ["add", "implement", "build", "develop", "progress", "continue"],
+    turning_point: ["feat:", "major", "significant", "pivot", "change", "transform"],
+    complication: ["issue", "problem", "bug", "error", "conflict", "challenge"],
+    crisis: ["critical", "urgent", "breaking", "emergency", "blocker"],
+    climax: ["complete", "finish", "final", "release", "launch", "deploy"],
+    resolution: ["fix", "resolve", "close", "merge", "done"],
+    denouement: ["cleanup", "refactor", "optimize", "polish", "improve"]
+  };
+}
+function analyzeStoryEnginePerspective(state) {
+  const event = state.event;
+  const content = extractContent(event);
+  const contentLower = content.toLowerCase();
+  const keywords = storyEngineIntentKeywords();
+  const intentScores = {};
+  for (const [intent2, terms] of Object.entries(keywords)) {
+    const score = terms.filter((term) => contentLower.includes(term)).length;
+    if (score > 0) {
+      intentScores[intent2] = score / terms.length;
+    }
+  }
+  let intent;
+  let confidence;
+  if (Object.keys(intentScores).length > 0) {
+    intent = Object.entries(intentScores).reduce(
+      (a, b) => a[1] > b[1] ? a : b
+    )[0];
+    confidence = Math.min(0.95, 0.55 + intentScores[intent] * 0.4);
+  } else {
+    intent = "rising_action";
+    confidence = 0.5;
+  }
+  const actMap = {
+    inciting_incident: 1,
+    rising_action: 2,
+    turning_point: 2,
+    complication: 2,
+    crisis: 2,
+    climax: 3,
+    resolution: 3,
+    denouement: 3
+  };
+  const act = actMap[intent] || 2;
+  const functionMap = {
+    inciting_incident: "inciting_incident",
+    rising_action: "rising_action",
+    turning_point: "turning_point",
+    complication: "complication",
+    crisis: "crisis",
+    climax: "climax",
+    resolution: "resolution",
+    denouement: "denouement"
+  };
+  const narrativeFunction = functionMap[intent] || "beat";
+  const flowMap = {
+    inciting_incident: ["establish_stakes", "introduce_characters", "set_tone"],
+    rising_action: ["advance_narrative", "develop_characters", "build_tension"],
+    turning_point: ["mark_pivot", "shift_perspective", "update_arc"],
+    complication: ["deepen_conflict", "raise_stakes", "add_obstacle"],
+    crisis: ["peak_tension", "force_decision", "approach_climax"],
+    climax: ["resolve_main_conflict", "character_transformation", "theme_revelation"],
+    resolution: ["tie_loose_ends", "show_consequences", "new_equilibrium"],
+    denouement: ["reflect_journey", "hint_future", "final_image"]
+  };
+  const suggestedFlows = flowMap[intent] || [
+    "advance_narrative",
+    "update_arc_position"
+  ];
+  const dramaticTension = calculateDramaticTension(intent, content);
+  const context = {
+    act,
+    narrativeFunction,
+    dramaticTension,
+    suggestedNextBeat: suggestNextBeat(intent),
+    characterImpact: assessCharacterImpact(content),
+    themeResonance: assessThemeResonance(content),
+    pacingSuggestion: suggestPacing(intent, dramaticTension)
+  };
+  const perspective = createUniversePerspective(
+    "story_engine" /* STORY_ENGINE */,
+    intent,
+    confidence,
+    { suggestedFlows, context }
+  );
+  return { ...state, storyEnginePerspective: perspective };
+}
+function calculateDramaticTension(intent, content) {
+  const baseTension = {
+    inciting_incident: 0.4,
+    rising_action: 0.5,
+    turning_point: 0.7,
+    complication: 0.6,
+    crisis: 0.9,
+    climax: 1,
+    resolution: 0.4,
+    denouement: 0.2
+  };
+  let tension = baseTension[intent] || 0.5;
+  const contentLower = content.toLowerCase();
+  if (["urgent", "critical", "breaking"].some((w) => contentLower.includes(w))) {
+    tension = Math.min(1, tension + 0.2);
+  }
+  if (["minor", "small", "trivial"].some((w) => contentLower.includes(w))) {
+    tension = Math.max(0.1, tension - 0.2);
+  }
+  return Math.round(tension * 100) / 100;
+}
+function suggestNextBeat(currentIntent) {
+  const nextBeatMap = {
+    inciting_incident: "rising_action",
+    rising_action: "complication",
+    turning_point: "rising_action",
+    complication: "crisis",
+    crisis: "climax",
+    climax: "resolution",
+    resolution: "denouement",
+    denouement: "inciting_incident"
+    // New cycle
+  };
+  return nextBeatMap[currentIntent] || "rising_action";
+}
+function assessCharacterImpact(content) {
+  const contentLower = content.toLowerCase();
+  if (["transform", "change", "grow", "learn"].some(
+    (w) => contentLower.includes(w)
+  )) {
+    return "transformative";
+  }
+  if (["challenge", "struggle", "overcome"].some(
+    (w) => contentLower.includes(w)
+  )) {
+    return "character_testing";
+  }
+  if (["connect", "relationship", "team"].some((w) => contentLower.includes(w))) {
+    return "relational";
+  }
+  return "incremental";
+}
+function assessThemeResonance(content) {
+  const contentLower = content.toLowerCase();
+  const themes = [];
+  if (["together", "team", "collaborate"].some((w) => contentLower.includes(w))) {
+    themes.push("collaboration");
+  }
+  if (["integrate", "connect", "bridge"].some((w) => contentLower.includes(w))) {
+    themes.push("integration");
+  }
+  if (["coherent", "consistent", "unified"].some(
+    (w) => contentLower.includes(w)
+  )) {
+    themes.push("coherence");
+  }
+  if (["transform", "change", "evolve"].some((w) => contentLower.includes(w))) {
+    themes.push("transformation");
+  }
+  return themes.length > 0 ? themes.join(", ") : "development";
+}
+function suggestPacing(intent, tension) {
+  if (tension > 0.8) return "accelerate";
+  if (tension < 0.3) return "breathe";
+  if (intent === "inciting_incident" || intent === "climax") return "emphasize";
+  return "steady";
+}
+function synthesizePerspectives(state) {
+  const engineer = state.engineerPerspective;
+  const ceremony = state.ceremonyPerspective;
+  const storyEngine = state.storyEnginePerspective;
+  if (!engineer || !ceremony || !storyEngine) {
+    return {
+      ...state,
+      error: "Missing one or more perspectives"
+    };
+  }
+  const lead = determineLeadUniverse(engineer, ceremony, storyEngine);
+  const coherence = calculateCoherence(engineer, ceremony, storyEngine);
+  const analysis = createThreeUniverseAnalysis(
+    engineer,
+    ceremony,
+    storyEngine,
+    lead,
+    coherence
+  );
+  return {
+    ...state,
+    analysis,
+    leadUniverse: lead,
+    coherenceScore: coherence
+  };
+}
+function determineLeadUniverse(engineer, ceremony, storyEngine) {
+  const ceremonyContext = ceremony.context;
+  if (ceremonyContext.witnessingNeeded) {
+    return "ceremony" /* CEREMONY */;
+  }
+  if (ceremonyContext.isCollaborative) {
+    return "ceremony" /* CEREMONY */;
+  }
+  const storyContext = storyEngine.context;
+  if (storyContext.dramaticTension > 0.8) {
+    return "story_engine" /* STORY_ENGINE */;
+  }
+  if (storyContext.narrativeFunction === "climax" || storyContext.narrativeFunction === "turning_point") {
+    return "story_engine" /* STORY_ENGINE */;
+  }
+  const engineerContext = engineer.context;
+  if (engineerContext.estimatedComplexity === "high") {
+    return "engineer" /* ENGINEER */;
+  }
+  if (engineer.intent === "security" || engineer.intent === "bug_fix") {
+    return "engineer" /* ENGINEER */;
+  }
+  const perspectives = [
+    [engineer, "engineer" /* ENGINEER */],
+    [ceremony, "ceremony" /* CEREMONY */],
+    [storyEngine, "story_engine" /* STORY_ENGINE */]
+  ];
+  return perspectives.reduce(
+    (a, b) => a[0].confidence > b[0].confidence ? a : b
+  )[1];
+}
+function calculateCoherence(engineer, ceremony, storyEngine) {
+  const avgConfidence = (engineer.confidence + ceremony.confidence + storyEngine.confidence) / 3;
+  let bonus = 0;
+  const engineerUrgent = ["security", "bug_fix", "performance"].includes(
+    engineer.intent
+  );
+  const ceremonyUrgent = ceremony.context.senderEnergy === "urgent_flow";
+  const storyUrgent = storyEngine.context.dramaticTension > 0.7;
+  if ([engineerUrgent, ceremonyUrgent, storyUrgent].filter(Boolean).length >= 2) {
+    bonus += 0.1;
+  }
+  const confidences = [
+    engineer.confidence,
+    ceremony.confidence,
+    storyEngine.confidence
+  ];
+  const confidenceSpread = Math.max(...confidences) - Math.min(...confidences);
+  const penalty = confidenceSpread * 0.2;
+  const coherence = avgConfidence + bonus - penalty;
+  return Math.round(Math.max(0, Math.min(1, coherence)) * 100) / 100;
+}
+var ThreeUniverseProcessor = class {
+  tracingCallback;
+  constructor(options = {}) {
+    this.tracingCallback = options.tracingCallback;
+  }
+  /**
+   * Process an event through all three universes.
+   *
+   * @param event The event data (webhook payload, user input, etc.)
+   * @param eventType Type of event (e.g., "github.push", "user.input")
+   * @returns ThreeUniverseAnalysis with all perspectives and synthesis
+   */
+  process(event, eventType = "unknown") {
+    let state = {
+      event,
+      eventType
+    };
+    state = analyzeEngineerPerspective(state);
+    state = analyzeCeremonyPerspective(state);
+    state = analyzeStoryEnginePerspective(state);
+    state = synthesizePerspectives(state);
+    if (state.error) {
+      throw new Error(`Processing error: ${state.error}`);
+    }
+    const analysis = state.analysis;
+    if (this.tracingCallback && analysis) {
+      const eventId = event.eventId || event.id || `${eventType}_${Date.now()}`;
+      const eventContent = this.extractEventContent(event);
+      this.tracingCallback(
+        eventId,
+        eventContent,
+        perspectiveToRecord(analysis.engineer),
+        perspectiveToRecord(analysis.ceremony),
+        perspectiveToRecord(analysis.storyEngine),
+        analysis.leadUniverse,
+        analysis.coherenceScore
+      );
+    }
+    return analysis;
+  }
+  extractEventContent(event) {
+    if (event.content) {
+      return String(event.content).slice(0, 500);
+    }
+    const payload = event.payload;
+    if (payload && typeof payload === "object") {
+      const issue = payload.issue;
+      if (issue?.title) return issue.title;
+      const pr = payload.pull_request;
+      if (pr?.title) return pr.title;
+      const comment = payload.comment;
+      if (comment?.body) return comment.body.slice(0, 500);
+    }
+    if (event.message) {
+      return String(event.message).slice(0, 500);
+    }
+    return `Event: ${event.eventType || "unknown"}`;
+  }
+  /**
+   * Convenience method for processing GitHub webhooks.
+   */
+  processWebhook(webhookPayload) {
+    let eventType = "github.push";
+    const payload = webhookPayload.payload;
+    if (payload) {
+      if (payload.issue) {
+        eventType = "github.issue";
+      } else if (payload.pull_request) {
+        eventType = "github.pull_request";
+      } else if (payload.comment) {
+        eventType = "github.comment";
+      }
+    }
+    return this.process(webhookPayload, eventType);
+  }
+  /**
+   * Create a story beat from event and analysis.
+   */
+  createBeatFromAnalysis(event, analysis, sequence) {
+    const functionMap = {
+      inciting_incident: "inciting_incident" /* INCITING_INCIDENT */,
+      rising_action: "rising_action" /* RISING_ACTION */,
+      turning_point: "turning_point" /* TURNING_POINT */,
+      complication: "complication" /* COMPLICATION */,
+      crisis: "crisis" /* CRISIS */,
+      climax: "climax" /* CLIMAX */,
+      resolution: "resolution" /* RESOLUTION */,
+      denouement: "denouement" /* DENOUEMENT */
+    };
+    const storyIntent = analysis.storyEngine.intent;
+    const narrativeFunc = functionMap[storyIntent] || "beat" /* BEAT */;
+    const act = analysis.storyEngine.context.act || 2;
+    let content = extractContent(event);
+    if (!content) {
+      content = String(event.eventType || "event");
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const beatId = `beat_${timestamp}`;
+    let sourceEventId;
+    const payload = event.payload;
+    if (payload) {
+      const headCommit = payload.head_commit;
+      if (headCommit?.id) {
+        sourceEventId = headCommit.id;
+      } else if (payload.issue) {
+        const issue = payload.issue;
+        sourceEventId = String(issue.id);
+      } else if (payload.pull_request) {
+        const pr = payload.pull_request;
+        sourceEventId = String(pr.id);
+      }
+    }
+    return createStoryBeat(beatId, sequence, content.slice(0, 500), narrativeFunc, act, {
+      universeAnalysis: analysis,
+      leadUniverse: analysis.leadUniverse,
+      source: "processor",
+      sourceEventId
+    });
+  }
+};
+function perspectiveToRecord(perspective) {
+  return {
+    universe: perspective.universe,
+    intent: perspective.intent,
+    confidence: perspective.confidence,
+    suggestedFlows: perspective.suggestedFlows,
+    context: perspective.context
+  };
+}
+
+// src/graphs/coherence_engine.ts
+var GapType = /* @__PURE__ */ ((GapType2) => {
+  GapType2["STRUCTURAL"] = "structural";
+  GapType2["THEMATIC"] = "thematic";
+  GapType2["CHARACTER"] = "character";
+  GapType2["SENSORY"] = "sensory";
+  GapType2["CONTINUITY"] = "continuity";
+  return GapType2;
+})(GapType || {});
+var GapSeverity = /* @__PURE__ */ ((GapSeverity2) => {
+  GapSeverity2["CRITICAL"] = "critical";
+  GapSeverity2["MODERATE"] = "moderate";
+  GapSeverity2["MINOR"] = "minor";
+  return GapSeverity2;
+})(GapSeverity || {});
+var RoutingTarget = /* @__PURE__ */ ((RoutingTarget2) => {
+  RoutingTarget2["STORYTELLER"] = "storyteller";
+  RoutingTarget2["STRUCTURIST"] = "structurist";
+  RoutingTarget2["ARCHITECT"] = "architect";
+  RoutingTarget2["AUTHOR"] = "author";
+  return RoutingTarget2;
+})(RoutingTarget || {});
+function createGap(id, gapType, severity, description, suggestedRoute, options = {}) {
+  return {
+    id,
+    gapType,
+    severity,
+    description,
+    location: options.location ?? {},
+    suggestedRoute,
+    resolved: options.resolved ?? false,
+    resolution: options.resolution
+  };
+}
+function createComponentScore(score, status, options = {}) {
+  return {
+    score,
+    status,
+    issues: options.issues ?? [],
+    suggestions: options.suggestions ?? []
+  };
+}
+function createCoherenceScore(overall, narrativeFlow, characterConsistency, pacing, themeSaturation, continuity) {
+  return {
+    overall,
+    narrativeFlow,
+    characterConsistency,
+    pacing,
+    themeSaturation,
+    continuity,
+    analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createTrinityAssessment(mia, miette, ava8, priorities = []) {
+  return { mia, miette, ava8, priorities };
+}
+var NarrativeCoherenceEngine = class {
+  strictMode;
+  gapCounter;
+  constructor(options = {}) {
+    this.strictMode = options.strictMode ?? false;
+    this.gapCounter = 0;
+  }
+  generateGapId() {
+    this.gapCounter += 1;
+    return `gap_${this.gapCounter}`;
+  }
+  /**
+   * Analyze narrative flow - how smoothly the story progresses.
+   *
+   * Checks:
+   * - Beat transitions (jarring vs smooth)
+   * - Logical causality between beats
+   * - Pacing consistency
+   */
+  analyzeNarrativeFlow(state) {
+    const beats = state.beats;
+    const issues = [];
+    const suggestions = [];
+    let score;
+    let status;
+    if (beats.length < 2) {
+      score = 50;
+      issues.push("Too few beats to assess flow");
+      suggestions.push("Add more story beats to establish narrative rhythm");
+    } else {
+      const functions = beats.map((b) => b.narrativeFunction);
+      let hasProperStructure = false;
+      for (let i = 0; i < functions.length; i++) {
+        const func = functions[i];
+        if (["setup", "introduction", "discovery"].includes(func)) {
+          hasProperStructure = true;
+          break;
+        } else if (["confrontation", "crisis", "climax"].includes(func)) {
+          if (!hasProperStructure) {
+            issues.push(`Beat ${i + 1} escalates without proper setup`);
+            hasProperStructure = true;
+          }
+        }
+      }
+      let prevTone;
+      let jarringTransitions = 0;
+      for (let i = 0; i < beats.length; i++) {
+        const beat = beats[i];
+        if (prevTone && beat.emotionalTone) {
+          const jarringPairs = [
+            ["devastating", "joyful"],
+            ["fearful", "peaceful"],
+            ["triumphant", "devastating"]
+          ];
+          for (const [p1, p2] of jarringPairs) {
+            if (prevTone.toLowerCase().includes(p1) && beat.emotionalTone.toLowerCase().includes(p2) || prevTone.toLowerCase().includes(p2) && beat.emotionalTone.toLowerCase().includes(p1)) {
+              jarringTransitions += 1;
+              issues.push(`Jarring emotional transition at Beat ${i + 1}`);
+            }
+          }
+        }
+        prevTone = beat.emotionalTone;
+      }
+      let baseScore = 85;
+      baseScore -= jarringTransitions * 10;
+      baseScore -= issues.filter((i) => i.includes("without proper setup")).length * 15;
+      score = Math.max(0, Math.min(100, baseScore));
+      if (jarringTransitions > 0) {
+        suggestions.push("Add transitional beats to smooth emotional shifts");
+      }
+      if (!hasProperStructure) {
+        suggestions.push(
+          "Consider adding setup beats before major confrontations"
+        );
+      }
+    }
+    if (score >= 70) {
+      status = "good";
+    } else if (score >= 50) {
+      status = "warning";
+    } else {
+      status = "critical";
+    }
+    state.narrativeFlowScore = createComponentScore(score, status, {
+      issues,
+      suggestions
+    });
+    return state;
+  }
+  /**
+   * Analyze character consistency across the narrative.
+   *
+   * Checks:
+   * - Character voice consistency
+   * - Arc progression logic
+   * - Relationship evolution coherence
+   */
+  analyzeCharacterConsistency(state) {
+    const beats = state.beats;
+    const characters = state.characters;
+    const issues = [];
+    const suggestions = [];
+    let score;
+    let status;
+    if (characters.length === 0) {
+      score = 50;
+      issues.push("No character data provided");
+      suggestions.push("Define character states to enable consistency analysis");
+    } else {
+      const characterBeats = {};
+      for (const char of characters) {
+        characterBeats[char.id] = [];
+      }
+      for (let i = 0; i < beats.length; i++) {
+        const beat = beats[i];
+        if (beat.characterId && characterBeats[beat.characterId]) {
+          characterBeats[beat.characterId].push(i);
+        }
+      }
+      for (const [charId, appearances] of Object.entries(characterBeats)) {
+        if (appearances.length >= 2) {
+          for (let i = 1; i < appearances.length; i++) {
+            const gap = appearances[i] - appearances[i - 1];
+            if (gap > 5) {
+              const char = characters.find((c) => c.id === charId);
+              const name = char?.name || charId;
+              issues.push(`Character '${name}' disappears for ${gap} beats`);
+              suggestions.push(
+                `Consider adding '${name}' to beats between ${appearances[i - 1] + 1} and ${appearances[i] + 1}`
+              );
+            }
+          }
+        }
+      }
+      for (const char of characters) {
+        if (char.arcPosition < 0.1 && beats.length > 5) {
+          issues.push(`Character '${char.name}' has minimal arc progression`);
+        }
+      }
+      let baseScore = 90;
+      baseScore -= issues.filter((i) => i.includes("disappears")).length * 8;
+      baseScore -= issues.filter((i) => i.includes("minimal arc")).length * 12;
+      score = Math.max(0, Math.min(100, baseScore));
+    }
+    if (score >= 70) {
+      status = "good";
+    } else if (score >= 50) {
+      status = "warning";
+    } else {
+      status = "critical";
+    }
+    state.characterConsistencyScore = createComponentScore(score, status, {
+      issues,
+      suggestions
+    });
+    return state;
+  }
+  /**
+   * Analyze narrative pacing.
+   *
+   * Checks:
+   * - Tension/relief distribution
+   * - Beat density per section
+   * - Climax positioning
+   */
+  analyzePacing(state) {
+    const beats = state.beats;
+    const issues = [];
+    const suggestions = [];
+    let score;
+    let status;
+    if (beats.length < 3) {
+      score = 50;
+      issues.push("Too few beats to assess pacing");
+      suggestions.push("Add more beats to establish proper pacing rhythm");
+    } else {
+      const functions = beats.map((b) => b.narrativeFunction.toLowerCase());
+      const climaxPositions = functions.map((f, i) => f.includes("climax") ? i : -1).filter((i) => i >= 0);
+      if (climaxPositions.length === 0) {
+        issues.push("No climax beat identified");
+        suggestions.push("Ensure at least one beat has a climax function");
+      } else {
+        const lastClimax = climaxPositions[climaxPositions.length - 1];
+        const total = beats.length;
+        if (lastClimax < total * 0.5) {
+          issues.push("Climax occurs too early in the narrative");
+          suggestions.push(
+            "Move climax to later in the story or add post-climax resolution beats"
+          );
+        }
+      }
+      const highTensionFuncs = [
+        "confrontation",
+        "crisis",
+        "climax",
+        "revelation"
+      ];
+      let consecutiveHigh = 0;
+      let maxConsecutive = 0;
+      for (const func of functions) {
+        if (highTensionFuncs.some((ht) => func.includes(ht))) {
+          consecutiveHigh += 1;
+          maxConsecutive = Math.max(maxConsecutive, consecutiveHigh);
+        } else {
+          consecutiveHigh = 0;
+        }
+      }
+      if (maxConsecutive > 3) {
+        issues.push(
+          `Found ${maxConsecutive} consecutive high-tension beats`
+        );
+        suggestions.push(
+          "Add breathing room with quieter beats between intense moments"
+        );
+      }
+      let baseScore = 85;
+      if (climaxPositions.length === 0) {
+        baseScore -= 20;
+      } else if (climaxPositions[climaxPositions.length - 1] < beats.length * 0.5) {
+        baseScore -= 15;
+      }
+      baseScore -= Math.min(20, maxConsecutive * 5);
+      score = Math.max(0, Math.min(100, baseScore));
+    }
+    if (score >= 70) {
+      status = "good";
+    } else if (score >= 50) {
+      status = "warning";
+    } else {
+      status = "critical";
+    }
+    state.pacingScore = createComponentScore(score, status, {
+      issues,
+      suggestions
+    });
+    return state;
+  }
+  /**
+   * Analyze how well themes permeate the narrative.
+   *
+   * Checks:
+   * - Theme presence across beats
+   * - Theme introduction and payoff
+   * - Theme strength consistency
+   */
+  analyzeThemeSaturation(state) {
+    const beats = state.beats;
+    const themes = state.themes;
+    const issues = [];
+    const suggestions = [];
+    let score;
+    let status;
+    if (themes.length === 0) {
+      score = 50;
+      issues.push("No themes defined");
+      suggestions.push(
+        "Define thematic threads to enable saturation analysis"
+      );
+    } else {
+      const themeCoverage = {};
+      for (const theme of themes) {
+        let beatsWithTheme = 0;
+        for (const beat of beats) {
+          if (beat.thematicTags?.includes(theme.id)) {
+            beatsWithTheme += 1;
+          }
+        }
+        const coverage = beatsWithTheme / Math.max(beats.length, 1);
+        themeCoverage[theme.name] = coverage;
+        if (coverage < 0.2 && theme.strength > 0.5) {
+          issues.push(
+            `Theme '${theme.name}' is important but appears rarely`
+          );
+          suggestions.push(
+            `Weave '${theme.name}' into more beats to fulfill its promise`
+          );
+        }
+        if (coverage > 0.3 && theme.strength < 0.3) {
+          issues.push(
+            `Theme '${theme.name}' appears often but lacks impact`
+          );
+          suggestions.push(
+            `Strengthen the thematic weight of '${theme.name}' in key beats`
+          );
+        }
+      }
+      const coverageValues = Object.values(themeCoverage);
+      const avgCoverage = coverageValues.reduce((a, b) => a + b, 0) / Math.max(coverageValues.length, 1);
+      let baseScore = Math.min(100, avgCoverage * 100 + 20);
+      baseScore -= issues.filter((i) => i.includes("rarely")).length * 10;
+      baseScore -= issues.filter((i) => i.includes("lacks impact")).length * 8;
+      score = Math.max(0, Math.min(100, baseScore));
+    }
+    if (score >= 70) {
+      status = "good";
+    } else if (score >= 50) {
+      status = "warning";
+    } else {
+      status = "critical";
+    }
+    state.themeSaturationScore = createComponentScore(score, status, {
+      issues,
+      suggestions
+    });
+    return state;
+  }
+  /**
+   * Analyze narrative continuity.
+   *
+   * Checks:
+   * - Timeline consistency
+   * - Detail consistency across beats
+   * - Setting/location coherence
+   */
+  analyzeContinuity(state) {
+    const beats = state.beats;
+    const issues = [];
+    const suggestions = [];
+    let score;
+    let status;
+    if (beats.length < 2) {
+      score = 70;
+      issues.push("Too few beats for continuity analysis");
+    } else {
+      const sequences = beats.map((b) => b.sequence);
+      const sortedSequences = [...sequences].sort((a, b) => a - b);
+      if (JSON.stringify(sequences) !== JSON.stringify(sortedSequences)) {
+        issues.push("Beat sequences are not in order");
+        suggestions.push("Reorder beats to ensure logical sequence progression");
+      }
+      if (sequences.length !== new Set(sequences).size) {
+        issues.push("Duplicate beat sequence numbers found");
+        suggestions.push("Ensure each beat has a unique sequence number");
+      }
+      const maxSeq = Math.max(...sequences);
+      const expected = new Set(
+        Array.from({ length: maxSeq }, (_, i) => i + 1)
+      );
+      const actual = new Set(sequences);
+      const missing = [...expected].filter((x) => !actual.has(x));
+      if (missing.length > 0 && missing.length <= 3) {
+        issues.push(`Missing beat sequences: ${missing.sort().join(", ")}`);
+        suggestions.push("Fill in missing beat sequences or renumber");
+      }
+      let baseScore = 90;
+      baseScore -= issues.filter((i) => i.includes("not in order")).length * 20;
+      baseScore -= issues.filter((i) => i.includes("Duplicate")).length * 15;
+      baseScore -= issues.filter((i) => i.includes("Missing")).length * 5;
+      score = Math.max(0, Math.min(100, baseScore));
+    }
+    if (score >= 70) {
+      status = "good";
+    } else if (score >= 50) {
+      status = "warning";
+    } else {
+      status = "critical";
+    }
+    state.continuityScore = createComponentScore(score, status, {
+      issues,
+      suggestions
+    });
+    return state;
+  }
+  /**
+   * Calculate the overall coherence score from components.
+   */
+  calculateOverallScore(state) {
+    const components = [
+      state.narrativeFlowScore,
+      state.characterConsistencyScore,
+      state.pacingScore,
+      state.themeSaturationScore,
+      state.continuityScore
+    ];
+    const validScores = components.filter((c) => c !== void 0).map((c) => c.score);
+    if (validScores.length > 0) {
+      const weights = [1.2, 1.2, 1, 1, 0.8];
+      const weightedSum = validScores.reduce(
+        (sum, s, i) => sum + s * weights[i],
+        0
+      );
+      const totalWeight = weights.slice(0, validScores.length).reduce((a, b) => a + b, 0);
+      state.overallScore = weightedSum / totalWeight;
+    } else {
+      state.overallScore = 50;
+    }
+    return state;
+  }
+  /**
+   * Identify narrative gaps from component analyses.
+   */
+  identifyGaps(state) {
+    const gaps = [];
+    const componentMappings = [
+      ["narrativeFlowScore", "structural" /* STRUCTURAL */],
+      ["characterConsistencyScore", "character" /* CHARACTER */],
+      ["pacingScore", "structural" /* STRUCTURAL */],
+      ["themeSaturationScore", "thematic" /* THEMATIC */],
+      ["continuityScore", "continuity" /* CONTINUITY */]
+    ];
+    for (const [componentKey, gapType] of componentMappings) {
+      const component = state[componentKey];
+      if (component?.issues) {
+        for (const issue of component.issues) {
+          let severity;
+          if (component.status === "critical") {
+            severity = "critical" /* CRITICAL */;
+          } else if (issue.includes("rarely") || issue.includes("disappears")) {
+            severity = "moderate" /* MODERATE */;
+          } else {
+            severity = "minor" /* MINOR */;
+          }
+          let route;
+          if (gapType === "structural" /* STRUCTURAL */) {
+            route = "structurist" /* STRUCTURIST */;
+          } else if (gapType === "character" /* CHARACTER */) {
+            route = "storyteller" /* STORYTELLER */;
+          } else if (gapType === "thematic" /* THEMATIC */) {
+            route = "structurist" /* STRUCTURIST */;
+          } else if (gapType === "sensory" /* SENSORY */) {
+            route = "storyteller" /* STORYTELLER */;
+          } else {
+            route = "author" /* AUTHOR */;
+          }
+          gaps.push(
+            createGap(
+              this.generateGapId(),
+              gapType,
+              severity,
+              issue,
+              route,
+              { location: { component: componentKey } }
+            )
+          );
+        }
+      }
+    }
+    const severityOrder = {
+      ["critical" /* CRITICAL */]: 0,
+      ["moderate" /* MODERATE */]: 1,
+      ["minor" /* MINOR */]: 2
+    };
+    gaps.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);
+    state.gaps = gaps;
+    return state;
+  }
+  /**
+   * Generate Trinity perspective assessment (Mia/Miette/Ava8).
+   *
+   * Each persona provides feedback aligned with their perspective:
+   * - Mia 🧠: Structural/logical analysis
+   * - Miette 🌸: Emotional/resonance analysis
+   * - Ava8 🎨: Atmospheric/sensory analysis
+   */
+  generateTrinityAssessment(state) {
+    const gaps = state.gaps || [];
+    const flow = state.narrativeFlowScore;
+    const character = state.characterConsistencyScore;
+    const pacing = state.pacingScore;
+    const theme = state.themeSaturationScore;
+    const continuity = state.continuityScore;
+    const miaParts = [];
+    if (flow) {
+      miaParts.push(`Structure is ${flow.score.toFixed(0)}% sound.`);
+      if (flow.issues.length > 0) {
+        miaParts.push(`Key structural gap: ${flow.issues[0]}`);
+      }
+    }
+    if (pacing && pacing.score < 70) {
+      miaParts.push(`Pacing needs attention (${pacing.score.toFixed(0)}%).`);
+      if (pacing.suggestions.length > 0) {
+        miaParts.push(pacing.suggestions[0]);
+      }
+    }
+    if (continuity && continuity.score < 80) {
+      miaParts.push(
+        `Continuity has ${continuity.issues.length} issues to address.`
+      );
+    }
+    const mia = miaParts.length > 0 ? miaParts.join(" ") : "Structure analysis unavailable.";
+    const mietteParts = [];
+    if (character) {
+      if (character.score >= 80) {
+        mietteParts.push("Character arcs are resonating well.");
+      } else {
+        mietteParts.push(
+          `Character consistency is ${character.score.toFixed(0)}%.`
+        );
+        if (character.issues.length > 0) {
+          mietteParts.push(`The emotional gap: ${character.issues[0]}`);
+        }
+      }
+    }
+    if (theme) {
+      if (theme.score >= 70) {
+        mietteParts.push("Themes are landing with emotional weight.");
+      } else {
+        mietteParts.push("Themes need stronger emotional anchoring.");
+      }
+    }
+    if (flow?.issues) {
+      const jarring = flow.issues.filter((i) => i.includes("Jarring"));
+      if (jarring.length > 0) {
+        mietteParts.push("Emotional transitions feel abrupt in places.");
+      }
+    }
+    const miette = mietteParts.length > 0 ? mietteParts.join(" ") : "Emotional analysis unavailable.";
+    const ava8Parts = [];
+    const sensoryGaps = gaps.filter((g) => g.gapType === "sensory" /* SENSORY */);
+    if (sensoryGaps.length > 0) {
+      ava8Parts.push(`Found ${sensoryGaps.length} sensory gaps to address.`);
+    }
+    if (pacing && pacing.score >= 70) {
+      ava8Parts.push("Atmospheric rhythm feels balanced.");
+    } else {
+      ava8Parts.push("Atmosphere could use more grounding moments.");
+    }
+    if (pacing?.issues.some((i) => i.includes("consecutive high-tension"))) {
+      ava8Parts.push(
+        "The dense tension sections may benefit from visual breathing room."
+      );
+    }
+    const ava8 = ava8Parts.length > 0 ? ava8Parts.join(" ") : "Atmospheric analysis unavailable.";
+    const priorities = [];
+    const criticalGaps = gaps.filter(
+      (g) => g.severity === "critical" /* CRITICAL */
+    );
+    if (criticalGaps.length > 0) {
+      priorities.push(...criticalGaps.slice(0, 3).map((g) => g.description));
+    } else {
+      const moderateGaps = gaps.filter(
+        (g) => g.severity === "moderate" /* MODERATE */
+      );
+      if (moderateGaps.length > 0) {
+        priorities.push(
+          ...moderateGaps.slice(0, 3).map((g) => g.description)
+        );
+      }
+    }
+    if (priorities.length === 0) {
+      priorities.push("Minor polish items only - narrative is coherent");
+    }
+    state.trinityAssessment = createTrinityAssessment(
+      mia,
+      miette,
+      ava8,
+      priorities
+    );
+    return state;
+  }
+  /**
+   * Build the final coherence result object.
+   */
+  buildCoherenceResult(state) {
+    state.coherenceScore = createCoherenceScore(
+      state.overallScore || 50,
+      state.narrativeFlowScore || createComponentScore(50, "warning"),
+      state.characterConsistencyScore || createComponentScore(50, "warning"),
+      state.pacingScore || createComponentScore(50, "warning"),
+      state.themeSaturationScore || createComponentScore(50, "warning"),
+      state.continuityScore || createComponentScore(50, "warning")
+    );
+    return state;
+  }
+  /**
+   * Analyze narrative coherence.
+   *
+   * @param beats List of story beats to analyze
+   * @param characters Optional list of character states
+   * @param themes Optional list of thematic threads
+   * @param includeMetadata Whether to include full analysis state
+   * @returns CoherenceResult with coherenceScore, gaps, and trinityAssessment
+   */
+  analyze(beats, characters = [], themes = [], includeMetadata = false) {
+    let state = {
+      beats,
+      characters,
+      themes
+    };
+    state = this.analyzeNarrativeFlow(state);
+    state = this.analyzeCharacterConsistency(state);
+    state = this.analyzePacing(state);
+    state = this.analyzeThemeSaturation(state);
+    state = this.analyzeContinuity(state);
+    state = this.calculateOverallScore(state);
+    state = this.identifyGaps(state);
+    state = this.generateTrinityAssessment(state);
+    state = this.buildCoherenceResult(state);
+    if (includeMetadata) {
+      return state;
+    } else {
+      return {
+        coherenceScore: state.coherenceScore,
+        gaps: state.gaps || [],
+        trinityAssessment: state.trinityAssessment
+      };
+    }
+  }
+  /**
+   * Group gaps by their routing target.
+   *
+   * @param gaps List of identified gaps
+   * @returns Dictionary mapping routing target to list of gaps
+   */
+  getRoutingSuggestions(gaps) {
+    const routing = {
+      ["storyteller" /* STORYTELLER */]: [],
+      ["structurist" /* STRUCTURIST */]: [],
+      ["architect" /* ARCHITECT */]: [],
+      ["author" /* AUTHOR */]: []
+    };
+    for (const gap of gaps) {
+      routing[gap.suggestedRoute].push(gap);
+    }
+    return routing;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventType,
+  GapSeverity,
+  GapType,
+  NarrativeCoherenceEngine,
+  RoutingTarget,
+  ThreeUniverseProcessor,
+  analyzeCeremonyPerspective,
+  analyzeEngineerPerspective,
+  analyzeStoryEnginePerspective,
+  ceremonyIntentKeywords,
+  createCoherenceScore,
+  createComponentScore,
+  createGap,
+  createTrinityAssessment,
+  engineerIntentKeywords,
+  storyEngineIntentKeywords,
+  synthesizePerspectives
+});
+//# sourceMappingURL=index.cjs.map