@narrative-os/engine 0.1.0

package/dist/agents/canonValidator.d.ts

@@ -0,0 +1,9 @@
+import type { CanonStore } from '../memory/canonStore.js';
+export interface CanonValidationResult {
+    valid: boolean;
+    violations: string[];
+}
+export declare class CanonValidator {
+    validate(chapterText: string, canon: CanonStore): Promise<CanonValidationResult>;
+}
+export declare const canonValidator: CanonValidator;

package/dist/agents/canonValidator.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonValidator = exports.CanonValidator = void 0;
+const client_js_1 = require("../llm/client.js");
+const VALIDATOR_PROMPT = `Check the following chapter against the Story Canon. Identify any contradictions.
+
+## Story Canon
+{{canon}}
+
+## Chapter Text
+{{chapterText}}
+
+## Instructions
+List any contradictions between the chapter and the canon facts. A contradiction occurs when:
+- A character's status/background is different from canon
+- A plot thread status is contradicted
+- World rules are violated
+
+Return JSON:
+{
+  "valid": true/false,
+  "violations": ["description of contradiction 1", "description of contradiction 2"]
+}
+
+If no contradictions, return {"valid": true, "violations": []}`;
+class CanonValidator {
+    async validate(chapterText, canon) {
+        if (canon.facts.length === 0) {
+            return { valid: true, violations: [] };
+        }
+        const { formatCanonForPrompt } = await import('../memory/canonStore.js');
+        const canonSection = formatCanonForPrompt(canon);
+        const prompt = VALIDATOR_PROMPT
+            .replace('{{canon}}', canonSection)
+            .replace('{{chapterText}}', chapterText.substring(0, 3000));
+        const response = await (0, client_js_1.getLLM)().complete(prompt, {
+            temperature: 0.1,
+            maxTokens: 500,
+        });
+        try {
+            const result = JSON.parse(response);
+            return result;
+        }
+        catch {
+            return { valid: true, violations: [] };
+        }
+    }
+}
+exports.CanonValidator = CanonValidator;
+exports.canonValidator = new CanonValidator();
+//# sourceMappingURL=data:application/json;base64,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

package/dist/agents/chapterPlanner.d.ts

@@ -0,0 +1,50 @@
+import type { StoryBible, StoryState } from '../types/index.js';
+import type { StoryStructuredState } from '../story/structuredState.js';
+import type { DirectorOutput, ChapterObjective } from './storyDirector.js';
+export interface Scene {
+    id: string;
+    sequence: number;
+    goal: string;
+    description: string;
+    tension: number;
+    characters: string[];
+    setting: string;
+    estimatedWords: number;
+}
+export interface ChapterOutline {
+    chapterNumber: number;
+    overallGoal: string;
+    tone: string;
+    totalEstimatedWords: number;
+    scenes: Scene[];
+    transitions: string[];
+    notes: string;
+}
+export interface PlannerContext {
+    bible: StoryBible;
+    state: StoryState;
+    structuredState: StoryStructuredState;
+    directorOutput: DirectorOutput;
+    targetWordCount?: number;
+}
+export declare class ChapterPlanner {
+    plan(context: PlannerContext): Promise<ChapterOutline>;
+    private buildPrompt;
+    /**
+     * Format chapter outline for writer prompt
+     */
+    formatForPrompt(outline: ChapterOutline): string;
+    /**
+     * Generate fallback outline without LLM
+     */
+    generateFallbackOutline(directorOutput: DirectorOutput, targetWordCount?: number): ChapterOutline;
+    /**
+     * Validate that outline meets objectives
+     */
+    validateOutline(outline: ChapterOutline, objectives: ChapterObjective[]): {
+        valid: boolean;
+        coverage: number;
+        missedObjectives: string[];
+    };
+}
+export declare const chapterPlanner: ChapterPlanner;

package/dist/agents/chapterPlanner.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chapterPlanner = exports.ChapterPlanner = void 0;
+const client_js_1 = require("../llm/client.js");
+const CHAPTER_PLANNER_PROMPT = `You are the Chapter Planner for a narrative AI system. Convert chapter objectives into a detailed scene-by-scene outline.
+
+## Story Context
+
+**Title:** {{title}}
+**Genre:** {{genre}}
+**Setting:** {{setting}}
+
+## Chapter Direction
+
+**Chapter:** {{chapterNumber}}
+**Overall Goal:** {{overallGoal}}
+**Tone:** {{tone}}
+**Target Word Count:** {{targetWordCount}}
+
+### Objectives (in priority order)
+{{objectives}}
+
+### Focus Characters
+{{focusCharacters}}
+
+### Suggested Scenes
+{{suggestedScenes}}
+
+## Current Story State
+
+**Story Tension:** {{storyTension}}%
+**Target Tension:** {{targetTension}}%
+
+### Character States
+{{characters}}
+
+### Active Plot Threads
+{{plotThreads}}
+
+## Your Task
+
+Create a detailed scene-by-scene outline for this chapter. Each scene should:
+1. Have a clear goal that serves the chapter objectives
+2. Build tension progressively toward the chapter climax
+3. Include specific characters and setting
+4. Have an estimated word count (scenes typically 300-800 words)
+
+Output JSON with this structure:
+
+{
+  "chapterNumber": {{chapterNumber}},
+  "overallGoal": "{{overallGoal}}",
+  "tone": "{{tone}}",
+  "totalEstimatedWords": 2500,
+  "scenes": [
+    {
+      "id": "scene-1",
+      "sequence": 1,
+      "goal": "What this scene accomplishes",
+      "description": "Detailed description of what happens",
+      "tension": 0.2,
+      "characters": ["Character names present"],
+      "setting": "Where scene takes place",
+      "estimatedWords": 400
+    }
+  ],
+  "transitions": ["How scenes connect"],
+  "notes": "Additional guidance for the writer"
+}
+
+Guidelines:
+- Create 3-6 scenes per chapter
+- Tension should build progressively (low → medium → high)
+- Each scene should serve at least one objective
+- Opening scene: establish situation
+- Middle scenes: develop conflict, advance objectives
+- Final scene: climax or resolution hook
+- Total word count should match target (default ~2500)`;
+class ChapterPlanner {
+    async plan(context) {
+        const { bible, state, structuredState, directorOutput, targetWordCount = 2500 } = context;
+        const prompt = this.buildPrompt(bible, state, structuredState, directorOutput, targetWordCount);
+        const result = await (0, client_js_1.getLLM)().completeJSON(prompt, {
+            temperature: 0.4,
+            maxTokens: 2500,
+        });
+        return result;
+    }
+    buildPrompt(bible, state, structuredState, directorOutput, targetWordCount) {
+        const currentTension = Math.round(structuredState.tension * 100);
+        const targetTension = Math.round(4 * (state.currentChapter / state.totalChapters) * (1 - state.currentChapter / state.totalChapters) * 100);
+        // Format objectives
+        const objectives = directorOutput.objectives
+            .map(obj => {
+            const priorityEmoji = { critical: '🔴', high: '🟠', medium: '🟡', low: '🟢' }[obj.priority];
+            return `${priorityEmoji} [${obj.type.toUpperCase()}] ${obj.description}`;
+        })
+            .join('\n');
+        // Format characters
+        const characters = Object.values(structuredState.characters)
+            .map(c => `- ${c.name}: ${c.emotionalState}, at ${c.location}`)
+            .join('\n') || 'No character data.';
+        // Format plot threads
+        const plotThreads = Object.values(structuredState.plotThreads)
+            .filter(t => t.status !== 'resolved')
+            .map(t => `- ${t.name} (${t.status}, ${Math.round(t.tension * 100)}% tension)`)
+            .join('\n') || 'No active plot threads.';
+        // Format suggested scenes
+        const suggestedScenes = directorOutput.suggestedScenes
+            .map(s => `- ${s}`)
+            .join('\n') || 'No suggestions.';
+        return CHAPTER_PLANNER_PROMPT
+            .replace('{{title}}', bible.title)
+            .replace('{{genre}}', bible.genre)
+            .replace('{{setting}}', bible.setting)
+            .replace(/{{chapterNumber}}/g, directorOutput.chapterNumber.toString())
+            .replace('{{overallGoal}}', directorOutput.overallGoal)
+            .replace('{{tone}}', directorOutput.tone)
+            .replace('{{targetWordCount}}', `${targetWordCount} words`)
+            .replace('{{objectives}}', objectives)
+            .replace('{{focusCharacters}}', directorOutput.focusCharacters.join(', '))
+            .replace('{{suggestedScenes}}', suggestedScenes)
+            .replace('{{storyTension}}', currentTension.toString())
+            .replace('{{targetTension}}', targetTension.toString())
+            .replace('{{characters}}', characters)
+            .replace('{{plotThreads}}', plotThreads);
+    }
+    /**
+     * Format chapter outline for writer prompt
+     */
+    formatForPrompt(outline) {
+        const lines = ['## Chapter Outline'];
+        lines.push(`\n**Chapter ${outline.chapterNumber}: ${outline.overallGoal}**`);
+        lines.push(`**Tone:** ${outline.tone}`);
+        lines.push(`**Estimated Length:** ${outline.totalEstimatedWords} words`);
+        if (outline.scenes.length > 0) {
+            lines.push('\n### Scene Breakdown');
+            for (const scene of outline.scenes) {
+                const tensionBar = '█'.repeat(Math.round(scene.tension * 10)) + '░'.repeat(10 - Math.round(scene.tension * 10));
+                lines.push(`\n**Scene ${scene.sequence}** [${tensionBar}] ${Math.round(scene.tension * 100)}% tension`);
+                lines.push(`- **Goal:** ${scene.goal}`);
+                lines.push(`- **Setting:** ${scene.setting}`);
+                lines.push(`- **Characters:** ${scene.characters.join(', ')}`);
+                lines.push(`- **Description:** ${scene.description}`);
+                lines.push(`- **Estimated:** ${scene.estimatedWords} words`);
+            }
+        }
+        if (outline.transitions.length > 0) {
+            lines.push('\n### Scene Transitions');
+            for (let i = 0; i < outline.transitions.length; i++) {
+                lines.push(`${i + 1} → ${i + 2}: ${outline.transitions[i]}`);
+            }
+        }
+        if (outline.notes) {
+            lines.push(`\n**Planner Notes:** ${outline.notes}`);
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Generate fallback outline without LLM
+     */
+    generateFallbackOutline(directorOutput, targetWordCount = 2500) {
+        const scenes = [];
+        const sceneCount = Math.max(3, Math.min(6, Math.floor(targetWordCount / 500)));
+        const wordsPerScene = Math.floor(targetWordCount / sceneCount);
+        // Build scenes based on objectives
+        const criticalObjectives = directorOutput.objectives.filter(o => o.priority === 'critical');
+        const highObjectives = directorOutput.objectives.filter(o => o.priority === 'high');
+        // Scene 1: Setup
+        scenes.push({
+            id: 'scene-1',
+            sequence: 1,
+            goal: 'Establish current situation and character states',
+            description: 'Opening scene that sets up the chapter context',
+            tension: 0.2,
+            characters: directorOutput.focusCharacters.slice(0, 2),
+            setting: 'Current location',
+            estimatedWords: wordsPerScene,
+        });
+        // Middle scenes: Build tension and address objectives
+        for (let i = 2; i < sceneCount; i++) {
+            const tension = 0.3 + (i / sceneCount) * 0.5; // Build from 30% to 80%
+            const objective = criticalObjectives[i - 2] || highObjectives[i - 2];
+            scenes.push({
+                id: `scene-${i}`,
+                sequence: i,
+                goal: objective ? `Address: ${objective.description.substring(0, 50)}...` : 'Develop plot and character',
+                description: objective
+                    ? `Scene focusing on ${objective.type} objective related to ${objective.relatedCharacter || 'plot'}`
+                    : 'Development scene advancing the story',
+                tension: Math.round(tension * 100) / 100,
+                characters: directorOutput.focusCharacters,
+                setting: 'Story location',
+                estimatedWords: wordsPerScene,
+            });
+        }
+        // Final scene: Climax/Resolution
+        scenes.push({
+            id: `scene-${sceneCount}`,
+            sequence: sceneCount,
+            goal: criticalObjectives[0]?.description || 'Chapter climax or resolution',
+            description: 'Climactic scene that resolves or escalates the chapter tension',
+            tension: 0.9,
+            characters: directorOutput.focusCharacters,
+            setting: 'Key location',
+            estimatedWords: wordsPerScene,
+        });
+        // Generate transitions
+        const transitions = [];
+        for (let i = 0; i < scenes.length - 1; i++) {
+            transitions.push(`Natural progression from ${scenes[i].goal} to ${scenes[i + 1].goal}`);
+        }
+        return {
+            chapterNumber: directorOutput.chapterNumber,
+            overallGoal: directorOutput.overallGoal,
+            tone: directorOutput.tone,
+            totalEstimatedWords: scenes.reduce((sum, s) => sum + s.estimatedWords, 0),
+            scenes,
+            transitions,
+            notes: 'Auto-generated outline based on director objectives. Adjust as needed for narrative flow.',
+        };
+    }
+    /**
+     * Validate that outline meets objectives
+     */
+    validateOutline(outline, objectives) {
+        const covered = new Set();
+        const missed = [];
+        // Check each objective against scenes
+        for (const obj of objectives) {
+            const isCovered = outline.scenes.some(scene => scene.goal.toLowerCase().includes(obj.type) ||
+                scene.description.toLowerCase().includes(obj.description.toLowerCase().substring(0, 20)));
+            if (isCovered) {
+                covered.add(obj.id);
+            }
+            else if (obj.priority === 'critical' || obj.priority === 'high') {
+                missed.push(obj.description);
+            }
+        }
+        const coverage = objectives.length > 0 ? covered.size / objectives.length : 1;
+        return {
+            valid: missed.length === 0,
+            coverage,
+            missedObjectives: missed,
+        };
+    }
+}
+exports.ChapterPlanner = ChapterPlanner;
+exports.chapterPlanner = new ChapterPlanner();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chapterPlanner.js","sourceRoot":"","sources":["../../src/agents/chapterPlanner.ts"],"names":[],"mappings":"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","sourcesContent":["import { getLLM } from '../llm/client.js';\r\nimport type { StoryBible, StoryState } from '../types/index.js';\r\nimport type { StoryStructuredState } from '../story/structuredState.js';\r\nimport type { DirectorOutput, ChapterObjective } from './storyDirector.js';\r\n\r\nexport interface Scene {\r\n  id: string;\r\n  sequence: number;\r\n  goal: string;\r\n  description: string;\r\n  tension: number; // 0.0 to 1.0\r\n  characters: string[];\r\n  setting: string;\r\n  estimatedWords: number;\r\n}\r\n\r\nexport interface ChapterOutline {\r\n  chapterNumber: number;\r\n  overallGoal: string;\r\n  tone: string;\r\n  totalEstimatedWords: number;\r\n  scenes: Scene[];\r\n  transitions: string[];\r\n  notes: string;\r\n}\r\n\r\nexport interface PlannerContext {\r\n  bible: StoryBible;\r\n  state: StoryState;\r\n  structuredState: StoryStructuredState;\r\n  directorOutput: DirectorOutput;\r\n  targetWordCount?: number;\r\n}\r\n\r\nconst CHAPTER_PLANNER_PROMPT = `You are the Chapter Planner for a narrative AI system. Convert chapter objectives into a detailed scene-by-scene outline.\r\n\r\n## Story Context\r\n\r\n**Title:** {{title}}\r\n**Genre:** {{genre}}\r\n**Setting:** {{setting}}\r\n\r\n## Chapter Direction\r\n\r\n**Chapter:** {{chapterNumber}}\r\n**Overall Goal:** {{overallGoal}}\r\n**Tone:** {{tone}}\r\n**Target Word Count:** {{targetWordCount}}\r\n\r\n### Objectives (in priority order)\r\n{{objectives}}\r\n\r\n### Focus Characters\r\n{{focusCharacters}}\r\n\r\n### Suggested Scenes\r\n{{suggestedScenes}}\r\n\r\n## Current Story State\r\n\r\n**Story Tension:** {{storyTension}}%\r\n**Target Tension:** {{targetTension}}%\r\n\r\n### Character States\r\n{{characters}}\r\n\r\n### Active Plot Threads\r\n{{plotThreads}}\r\n\r\n## Your Task\r\n\r\nCreate a detailed scene-by-scene outline for this chapter. Each scene should:\r\n1. Have a clear goal that serves the chapter objectives\r\n2. Build tension progressively toward the chapter climax\r\n3. Include specific characters and setting\r\n4. Have an estimated word count (scenes typically 300-800 words)\r\n\r\nOutput JSON with this structure:\r\n\r\n{\r\n  \"chapterNumber\": {{chapterNumber}},\r\n  \"overallGoal\": \"{{overallGoal}}\",\r\n  \"tone\": \"{{tone}}\",\r\n  \"totalEstimatedWords\": 2500,\r\n  \"scenes\": [\r\n    {\r\n      \"id\": \"scene-1\",\r\n      \"sequence\": 1,\r\n      \"goal\": \"What this scene accomplishes\",\r\n      \"description\": \"Detailed description of what happens\",\r\n      \"tension\": 0.2,\r\n      \"characters\": [\"Character names present\"],\r\n      \"setting\": \"Where scene takes place\",\r\n      \"estimatedWords\": 400\r\n    }\r\n  ],\r\n  \"transitions\": [\"How scenes connect\"],\r\n  \"notes\": \"Additional guidance for the writer\"\r\n}\r\n\r\nGuidelines:\r\n- Create 3-6 scenes per chapter\r\n- Tension should build progressively (low → medium → high)\r\n- Each scene should serve at least one objective\r\n- Opening scene: establish situation\r\n- Middle scenes: develop conflict, advance objectives\r\n- Final scene: climax or resolution hook\r\n- Total word count should match target (default ~2500)`;\r\n\r\nexport class ChapterPlanner {\r\n  async plan(context: PlannerContext): Promise<ChapterOutline> {\r\n    const { bible, state, structuredState, directorOutput, targetWordCount = 2500 } = context;\r\n    \r\n    const prompt = this.buildPrompt(bible, state, structuredState, directorOutput, targetWordCount);\r\n    \r\n    const result = await getLLM().completeJSON<ChapterOutline>(prompt, {\r\n      temperature: 0.4,\r\n      maxTokens: 2500,\r\n    });\r\n    \r\n    return result;\r\n  }\r\n  \r\n  private buildPrompt(\r\n    bible: StoryBible,\r\n    state: StoryState,\r\n    structuredState: StoryStructuredState,\r\n    directorOutput: DirectorOutput,\r\n    targetWordCount: number\r\n  ): string {\r\n    const currentTension = Math.round(structuredState.tension * 100);\r\n    const targetTension = Math.round(\r\n      4 * (state.currentChapter / state.totalChapters) * (1 - state.currentChapter / state.totalChapters) * 100\r\n    );\r\n    \r\n    // Format objectives\r\n    const objectives = directorOutput.objectives\r\n      .map(obj => {\r\n        const priorityEmoji = { critical: '🔴', high: '🟠', medium: '🟡', low: '🟢' }[obj.priority];\r\n        return `${priorityEmoji} [${obj.type.toUpperCase()}] ${obj.description}`;\r\n      })\r\n      .join('\\n');\r\n    \r\n    // Format characters\r\n    const characters = Object.values(structuredState.characters)\r\n      .map(c => `- ${c.name}: ${c.emotionalState}, at ${c.location}`)\r\n      .join('\\n') || 'No character data.';\r\n    \r\n    // Format plot threads\r\n    const plotThreads = Object.values(structuredState.plotThreads)\r\n      .filter(t => t.status !== 'resolved')\r\n      .map(t => `- ${t.name} (${t.status}, ${Math.round(t.tension * 100)}% tension)`)\r\n      .join('\\n') || 'No active plot threads.';\r\n    \r\n    // Format suggested scenes\r\n    const suggestedScenes = directorOutput.suggestedScenes\r\n      .map(s => `- ${s}`)\r\n      .join('\\n') || 'No suggestions.';\r\n    \r\n    return CHAPTER_PLANNER_PROMPT\r\n      .replace('{{title}}', bible.title)\r\n      .replace('{{genre}}', bible.genre)\r\n      .replace('{{setting}}', bible.setting)\r\n      .replace(/{{chapterNumber}}/g, directorOutput.chapterNumber.toString())\r\n      .replace('{{overallGoal}}', directorOutput.overallGoal)\r\n      .replace('{{tone}}', directorOutput.tone)\r\n      .replace('{{targetWordCount}}', `${targetWordCount} words`)\r\n      .replace('{{objectives}}', objectives)\r\n      .replace('{{focusCharacters}}', directorOutput.focusCharacters.join(', '))\r\n      .replace('{{suggestedScenes}}', suggestedScenes)\r\n      .replace('{{storyTension}}', currentTension.toString())\r\n      .replace('{{targetTension}}', targetTension.toString())\r\n      .replace('{{characters}}', characters)\r\n      .replace('{{plotThreads}}', plotThreads);\r\n  }\r\n  \r\n  /**\r\n   * Format chapter outline for writer prompt\r\n   */\r\n  formatForPrompt(outline: ChapterOutline): string {\r\n    const lines: string[] = ['## Chapter Outline'];\r\n    \r\n    lines.push(`\\n**Chapter ${outline.chapterNumber}: ${outline.overallGoal}**`);\r\n    lines.push(`**Tone:** ${outline.tone}`);\r\n    lines.push(`**Estimated Length:** ${outline.totalEstimatedWords} words`);\r\n    \r\n    if (outline.scenes.length > 0) {\r\n      lines.push('\\n### Scene Breakdown');\r\n      \r\n      for (const scene of outline.scenes) {\r\n        const tensionBar = '█'.repeat(Math.round(scene.tension * 10)) + '░'.repeat(10 - Math.round(scene.tension * 10));\r\n        lines.push(`\\n**Scene ${scene.sequence}** [${tensionBar}] ${Math.round(scene.tension * 100)}% tension`);\r\n        lines.push(`- **Goal:** ${scene.goal}`);\r\n        lines.push(`- **Setting:** ${scene.setting}`);\r\n        lines.push(`- **Characters:** ${scene.characters.join(', ')}`);\r\n        lines.push(`- **Description:** ${scene.description}`);\r\n        lines.push(`- **Estimated:** ${scene.estimatedWords} words`);\r\n      }\r\n    }\r\n    \r\n    if (outline.transitions.length > 0) {\r\n      lines.push('\\n### Scene Transitions');\r\n      for (let i = 0; i < outline.transitions.length; i++) {\r\n        lines.push(`${i + 1} → ${i + 2}: ${outline.transitions[i]}`);\r\n      }\r\n    }\r\n    \r\n    if (outline.notes) {\r\n      lines.push(`\\n**Planner Notes:** ${outline.notes}`);\r\n    }\r\n    \r\n    return lines.join('\\n');\r\n  }\r\n  \r\n  /**\r\n   * Generate fallback outline without LLM\r\n   */\r\n  generateFallbackOutline(\r\n    directorOutput: DirectorOutput,\r\n    targetWordCount: number = 2500\r\n  ): ChapterOutline {\r\n    const scenes: Scene[] = [];\r\n    const sceneCount = Math.max(3, Math.min(6, Math.floor(targetWordCount / 500)));\r\n    const wordsPerScene = Math.floor(targetWordCount / sceneCount);\r\n    \r\n    // Build scenes based on objectives\r\n    const criticalObjectives = directorOutput.objectives.filter(o => o.priority === 'critical');\r\n    const highObjectives = directorOutput.objectives.filter(o => o.priority === 'high');\r\n    \r\n    // Scene 1: Setup\r\n    scenes.push({\r\n      id: 'scene-1',\r\n      sequence: 1,\r\n      goal: 'Establish current situation and character states',\r\n      description: 'Opening scene that sets up the chapter context',\r\n      tension: 0.2,\r\n      characters: directorOutput.focusCharacters.slice(0, 2),\r\n      setting: 'Current location',\r\n      estimatedWords: wordsPerScene,\r\n    });\r\n    \r\n    // Middle scenes: Build tension and address objectives\r\n    for (let i = 2; i < sceneCount; i++) {\r\n      const tension = 0.3 + (i / sceneCount) * 0.5; // Build from 30% to 80%\r\n      const objective = criticalObjectives[i - 2] || highObjectives[i - 2];\r\n      \r\n      scenes.push({\r\n        id: `scene-${i}`,\r\n        sequence: i,\r\n        goal: objective ? `Address: ${objective.description.substring(0, 50)}...` : 'Develop plot and character',\r\n        description: objective \r\n          ? `Scene focusing on ${objective.type} objective related to ${objective.relatedCharacter || 'plot'}`\r\n          : 'Development scene advancing the story',\r\n        tension: Math.round(tension * 100) / 100,\r\n        characters: directorOutput.focusCharacters,\r\n        setting: 'Story location',\r\n        estimatedWords: wordsPerScene,\r\n      });\r\n    }\r\n    \r\n    // Final scene: Climax/Resolution\r\n    scenes.push({\r\n      id: `scene-${sceneCount}`,\r\n      sequence: sceneCount,\r\n      goal: criticalObjectives[0]?.description || 'Chapter climax or resolution',\r\n      description: 'Climactic scene that resolves or escalates the chapter tension',\r\n      tension: 0.9,\r\n      characters: directorOutput.focusCharacters,\r\n      setting: 'Key location',\r\n      estimatedWords: wordsPerScene,\r\n    });\r\n    \r\n    // Generate transitions\r\n    const transitions: string[] = [];\r\n    for (let i = 0; i < scenes.length - 1; i++) {\r\n      transitions.push(`Natural progression from ${scenes[i].goal} to ${scenes[i + 1].goal}`);\r\n    }\r\n    \r\n    return {\r\n      chapterNumber: directorOutput.chapterNumber,\r\n      overallGoal: directorOutput.overallGoal,\r\n      tone: directorOutput.tone,\r\n      totalEstimatedWords: scenes.reduce((sum, s) => sum + s.estimatedWords, 0),\r\n      scenes,\r\n      transitions,\r\n      notes: 'Auto-generated outline based on director objectives. Adjust as needed for narrative flow.',\r\n    };\r\n  }\r\n  \r\n  /**\r\n   * Validate that outline meets objectives\r\n   */\r\n  validateOutline(outline: ChapterOutline, objectives: ChapterObjective[]): {\r\n    valid: boolean;\r\n    coverage: number;\r\n    missedObjectives: string[];\r\n  } {\r\n    const covered = new Set<string>();\r\n    const missed: string[] = [];\r\n    \r\n    // Check each objective against scenes\r\n    for (const obj of objectives) {\r\n      const isCovered = outline.scenes.some(scene => \r\n        scene.goal.toLowerCase().includes(obj.type) ||\r\n        scene.description.toLowerCase().includes(obj.description.toLowerCase().substring(0, 20))\r\n      );\r\n      \r\n      if (isCovered) {\r\n        covered.add(obj.id);\r\n      } else if (obj.priority === 'critical' || obj.priority === 'high') {\r\n        missed.push(obj.description);\r\n      }\r\n    }\r\n    \r\n    const coverage = objectives.length > 0 ? covered.size / objectives.length : 1;\r\n    \r\n    return {\r\n      valid: missed.length === 0,\r\n      coverage,\r\n      missedObjectives: missed,\r\n    };\r\n  }\r\n}\r\n\r\nexport const chapterPlanner = new ChapterPlanner();\r\n"]}

package/dist/agents/completeness.d.ts

@@ -0,0 +1,7 @@
+import type { CompletenessResult } from '../types/index.js';
+export declare class CompletenessChecker {
+    private promptTemplate;
+    constructor();
+    check(chapterText: string): Promise<CompletenessResult>;
+}
+export declare const completenessChecker: CompletenessChecker;

package/dist/agents/completeness.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completenessChecker = exports.CompletenessChecker = void 0;
+const client_js_1 = require("../llm/client.js");
+const COMPLETENESS_PROMPT = `Determine whether the following chapter text ends at a natural stopping point.
+
+A chapter is COMPLETE if:
+- It ends at the end of a scene or chapter break
+- It does not cut off mid-sentence or mid-paragraph
+- It has narrative closure for this segment
+
+A chapter is INCOMPLETE if:
+- It cuts off mid-sentence
+- It ends abruptly mid-scene
+- The narrative clearly continues
+
+## Chapter Text
+
+{{chapterText}}
+
+## Response
+
+Return only one word:
+
+COMPLETE
+
+or
+
+INCOMPLETE`;
+class CompletenessChecker {
+    promptTemplate;
+    constructor() {
+        this.promptTemplate = COMPLETENESS_PROMPT;
+    }
+    async check(chapterText) {
+        const prompt = this.promptTemplate.replace('{{chapterText}}', chapterText);
+        const response = await (0, client_js_1.getLLM)().complete(prompt, {
+            temperature: 0.1,
+            maxTokens: 10,
+        });
+        const normalized = response.trim().toUpperCase();
+        const isComplete = normalized.includes('COMPLETE') && !normalized.includes('INCOMPLETE');
+        return {
+            isComplete,
+            reason: isComplete ? undefined : 'Chapter appears to be cut off mid-content',
+        };
+    }
+}
+exports.CompletenessChecker = CompletenessChecker;
+exports.completenessChecker = new CompletenessChecker();
+//# sourceMappingURL=data:application/json;base64,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

package/dist/agents/memoryExtractor.d.ts

@@ -0,0 +1,12 @@
+import type { Chapter, StoryBible } from '../types/index.js';
+import type { NarrativeMemory } from '../memory/vectorStore.js';
+interface ExtractedMemory {
+    content: string;
+    category: NarrativeMemory['category'];
+}
+export declare class MemoryExtractor {
+    extract(chapter: Chapter, bible: StoryBible): Promise<ExtractedMemory[]>;
+    extractFromSummary(chapterNumber: number, summary: string, bible: StoryBible): Promise<ExtractedMemory[]>;
+}
+export declare const memoryExtractor: MemoryExtractor;
+export {};

package/dist/agents/memoryExtractor.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryExtractor = exports.MemoryExtractor = void 0;
+const client_js_1 = require("../llm/client.js");
+const EXTRACTION_PROMPT = `You are a narrative memory extractor. Your job is to analyze a chapter and extract important facts that should be remembered for future chapters.
+
+## Story Bible
+
+**Title:** {{title}}
+**Genre:** {{genre}}
+**Setting:** {{setting}}
+
+## Chapter to Analyze
+
+**Chapter {{chapterNumber}}: {{chapterTitle}}**
+
+{{chapterContent}}
+
+## Extraction Task
+
+Extract 5-10 important narrative memories from this chapter. Focus on:
+
+1. **Events** - Significant things that happened (plot points, discoveries, battles, meetings)
+2. **Character** - Character development, new traits revealed, relationships changed
+3. **World** - New world details revealed (locations, cultures, magic systems, technology)
+4. **Plot** - Plot thread developments, mysteries introduced, foreshadowing
+
+For each memory:
+- Write a clear, standalone sentence that captures the fact
+- Categorize it appropriately
+- Be specific enough that it would be useful for maintaining continuity
+
+Respond with JSON only:
+{
+  "memories": [
+    {"content": "Alice discovered the ancient map hidden in her grandmother's attic", "category": "event"},
+    {"content": "Bob is secretly afraid of water due to a childhood drowning incident", "category": "character"},
+    {"content": "The city of Eldoria has a strict curfew enforced by mechanical guards", "category": "world"},
+    {"content": "The prophecy mentions three keys that must be found before the eclipse", "category": "plot"}
+  ]
+}`;
+class MemoryExtractor {
+    async extract(chapter, bible) {
+        const prompt = EXTRACTION_PROMPT
+            .replace('{{title}}', bible.title)
+            .replace('{{genre}}', bible.genre)
+            .replace('{{setting}}', bible.setting)
+            .replace('{{chapterNumber}}', chapter.number.toString())
+            .replace('{{chapterTitle}}', chapter.title)
+            .replace('{{chapterContent}}', chapter.content.substring(0, 8000)); // Limit content length
+        const result = await (0, client_js_1.getLLM)().completeJSON(prompt, {
+            temperature: 0.3,
+            maxTokens: 2000,
+        });
+        return result.memories || [];
+    }
+    async extractFromSummary(chapterNumber, summary, bible) {
+        const prompt = `You are a narrative memory extractor. Extract important facts from this chapter summary.
+
+## Story
+**Title:** ${bible.title}
+**Genre:** ${bible.genre}
+
+## Chapter ${chapterNumber} Summary
+${summary}
+
+Extract 3-5 key memories (events, character moments, world details, plot developments). Respond with JSON:
+{
+  "memories": [
+    {"content": "description of what happened", "category": "event|character|world|plot"}
+  ]
+}`;
+        const result = await (0, client_js_1.getLLM)().completeJSON(prompt, {
+            temperature: 0.3,
+            maxTokens: 1000,
+        });
+        return result.memories || [];
+    }
+}
+exports.MemoryExtractor = MemoryExtractor;
+exports.memoryExtractor = new MemoryExtractor();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVtb3J5RXh0cmFjdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FnZW50cy9tZW1vcnlFeHRyYWN0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsZ0RBQTBDO0FBYTFDLE1BQU0saUJBQWlCLEdBQUc7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztFQW9DeEIsQ0FBQztBQUVILE1BQWEsZUFBZTtJQUMxQixLQUFLLENBQUMsT0FBTyxDQUFDLE9BQWdCLEVBQUUsS0FBaUI7UUFDL0MsTUFBTSxNQUFNLEdBQUcsaUJBQWlCO2FBQzdCLE9BQU8sQ0FBQyxXQUFXLEVBQUUsS0FBSyxDQUFDLEtBQUssQ0FBQzthQUNqQyxPQUFPLENBQUMsV0FBVyxFQUFFLEtBQUssQ0FBQyxLQUFLLENBQUM7YUFDakMsT0FBTyxDQUFDLGFBQWEsRUFBRSxLQUFLLENBQUMsT0FBTyxDQUFDO2FBQ3JDLE9BQU8sQ0FBQyxtQkFBbUIsRUFBRSxPQUFPLENBQUMsTUFBTSxDQUFDLFFBQVEsRUFBRSxDQUFDO2FBQ3ZELE9BQU8sQ0FBQyxrQkFBa0IsRUFBRSxPQUFPLENBQUMsS0FBSyxDQUFDO2FBQzFDLE9BQU8sQ0FBQyxvQkFBb0IsRUFBRSxPQUFPLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDLEVBQUUsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLHVCQUF1QjtRQUU3RixNQUFNLE1BQU0sR0FBRyxNQUFNLElBQUEsa0JBQU0sR0FBRSxDQUFDLFlBQVksQ0FBbUIsTUFBTSxFQUFFO1lBQ25FLFdBQVcsRUFBRSxHQUFHO1lBQ2hCLFNBQVMsRUFBRSxJQUFJO1NBQ2hCLENBQUMsQ0FBQztRQUVILE9BQU8sTUFBTSxDQUFDLFFBQVEsSUFBSSxFQUFFLENBQUM7SUFDL0IsQ0FBQztJQUVELEtBQUssQ0FBQyxrQkFBa0IsQ0FBQyxhQUFxQixFQUFFLE9BQWUsRUFBRSxLQUFpQjtRQUNoRixNQUFNLE1BQU0sR0FBRzs7O2FBR04sS0FBSyxDQUFDLEtBQUs7YUFDWCxLQUFLLENBQUMsS0FBSzs7YUFFWCxhQUFhO0VBQ3hCLE9BQU87Ozs7Ozs7RUFPUCxDQUFDO1FBRUMsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFBLGtCQUFNLEdBQUUsQ0FBQyxZQUFZLENBQW1CLE1BQU0sRUFBRTtZQUNuRSxXQUFXLEVBQUUsR0FBRztZQUNoQixTQUFTLEVBQUUsSUFBSTtTQUNoQixDQUFDLENBQUM7UUFFSCxPQUFPLE1BQU0sQ0FBQyxRQUFRLElBQUksRUFBRSxDQUFDO0lBQy9CLENBQUM7Q0FDRjtBQTFDRCwwQ0EwQ0M7QUFFWSxRQUFBLGVBQWUsR0FBRyxJQUFJLGVBQWUsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZ2V0TExNIH0gZnJvbSAnLi4vbGxtL2NsaWVudC5qcyc7XHJcbmltcG9ydCB0eXBlIHsgQ2hhcHRlciwgU3RvcnlCaWJsZSB9IGZyb20gJy4uL3R5cGVzL2luZGV4LmpzJztcclxuaW1wb3J0IHR5cGUgeyBOYXJyYXRpdmVNZW1vcnkgfSBmcm9tICcuLi9tZW1vcnkvdmVjdG9yU3RvcmUuanMnO1xyXG5cclxuaW50ZXJmYWNlIEV4dHJhY3RlZE1lbW9yeSB7XHJcbiAgY29udGVudDogc3RyaW5nO1xyXG4gIGNhdGVnb3J5OiBOYXJyYXRpdmVNZW1vcnlbJ2NhdGVnb3J5J107XHJcbn1cclxuXHJcbmludGVyZmFjZSBFeHRyYWN0aW9uT3V0cHV0IHtcclxuICBtZW1vcmllczogRXh0cmFjdGVkTWVtb3J5W107XHJcbn1cclxuXHJcbmNvbnN0IEVYVFJBQ1RJT05fUFJPTVBUID0gYFlvdSBhcmUgYSBuYXJyYXRpdmUgbWVtb3J5IGV4dHJhY3Rvci4gWW91ciBqb2IgaXMgdG8gYW5hbHl6ZSBhIGNoYXB0ZXIgYW5kIGV4dHJhY3QgaW1wb3J0YW50IGZhY3RzIHRoYXQgc2hvdWxkIGJlIHJlbWVtYmVyZWQgZm9yIGZ1dHVyZSBjaGFwdGVycy5cclxuXHJcbiMjIFN0b3J5IEJpYmxlXHJcblxyXG4qKlRpdGxlOioqIHt7dGl0bGV9fVxyXG4qKkdlbnJlOioqIHt7Z2VucmV9fVxyXG4qKlNldHRpbmc6Kioge3tzZXR0aW5nfX1cclxuXHJcbiMjIENoYXB0ZXIgdG8gQW5hbHl6ZVxyXG5cclxuKipDaGFwdGVyIHt7Y2hhcHRlck51bWJlcn19OiB7e2NoYXB0ZXJUaXRsZX19KipcclxuXHJcbnt7Y2hhcHRlckNvbnRlbnR9fVxyXG5cclxuIyMgRXh0cmFjdGlvbiBUYXNrXHJcblxyXG5FeHRyYWN0IDUtMTAgaW1wb3J0YW50IG5hcnJhdGl2ZSBtZW1vcmllcyBmcm9tIHRoaXMgY2hhcHRlci4gRm9jdXMgb246XHJcblxyXG4xLiAqKkV2ZW50cyoqIC0gU2lnbmlmaWNhbnQgdGhpbmdzIHRoYXQgaGFwcGVuZWQgKHBsb3QgcG9pbnRzLCBkaXNjb3ZlcmllcywgYmF0dGxlcywgbWVldGluZ3MpXHJcbjIuICoqQ2hhcmFjdGVyKiogLSBDaGFyYWN0ZXIgZGV2ZWxvcG1lbnQsIG5ldyB0cmFpdHMgcmV2ZWFsZWQsIHJlbGF0aW9uc2hpcHMgY2hhbmdlZFxyXG4zLiAqKldvcmxkKiogLSBOZXcgd29ybGQgZGV0YWlscyByZXZlYWxlZCAobG9jYXRpb25zLCBjdWx0dXJlcywgbWFnaWMgc3lzdGVtcywgdGVjaG5vbG9neSlcclxuNC4gKipQbG90KiogLSBQbG90IHRocmVhZCBkZXZlbG9wbWVudHMsIG15c3RlcmllcyBpbnRyb2R1Y2VkLCBmb3Jlc2hhZG93aW5nXHJcblxyXG5Gb3IgZWFjaCBtZW1vcnk6XHJcbi0gV3JpdGUgYSBjbGVhciwgc3RhbmRhbG9uZSBzZW50ZW5jZSB0aGF0IGNhcHR1cmVzIHRoZSBmYWN0XHJcbi0gQ2F0ZWdvcml6ZSBpdCBhcHByb3ByaWF0ZWx5XHJcbi0gQmUgc3BlY2lmaWMgZW5vdWdoIHRoYXQgaXQgd291bGQgYmUgdXNlZnVsIGZvciBtYWludGFpbmluZyBjb250aW51aXR5XHJcblxyXG5SZXNwb25kIHdpdGggSlNPTiBvbmx5OlxyXG57XHJcbiAgXCJtZW1vcmllc1wiOiBbXHJcbiAgICB7XCJjb250ZW50XCI6IFwiQWxpY2UgZGlzY292ZXJlZCB0aGUgYW5jaWVudCBtYXAgaGlkZGVuIGluIGhlciBncmFuZG1vdGhlcidzIGF0dGljXCIsIFwiY2F0ZWdvcnlcIjogXCJldmVudFwifSxcclxuICAgIHtcImNvbnRlbnRcIjogXCJCb2IgaXMgc2VjcmV0bHkgYWZyYWlkIG9mIHdhdGVyIGR1ZSB0byBhIGNoaWxkaG9vZCBkcm93bmluZyBpbmNpZGVudFwiLCBcImNhdGVnb3J5XCI6IFwiY2hhcmFjdGVyXCJ9LFxyXG4gICAge1wiY29udGVudFwiOiBcIlRoZSBjaXR5IG9mIEVsZG9yaWEgaGFzIGEgc3RyaWN0IGN1cmZldyBlbmZvcmNlZCBieSBtZWNoYW5pY2FsIGd1YXJkc1wiLCBcImNhdGVnb3J5XCI6IFwid29ybGRcIn0sXHJcbiAgICB7XCJjb250ZW50XCI6IFwiVGhlIHByb3BoZWN5IG1lbnRpb25zIHRocmVlIGtleXMgdGhhdCBtdXN0IGJlIGZvdW5kIGJlZm9yZSB0aGUgZWNsaXBzZVwiLCBcImNhdGVnb3J5XCI6IFwicGxvdFwifVxyXG4gIF1cclxufWA7XHJcblxyXG5leHBvcnQgY2xhc3MgTWVtb3J5RXh0cmFjdG9yIHtcclxuICBhc3luYyBleHRyYWN0KGNoYXB0ZXI6IENoYXB0ZXIsIGJpYmxlOiBTdG9yeUJpYmxlKTogUHJvbWlzZTxFeHRyYWN0ZWRNZW1vcnlbXT4ge1xyXG4gICAgY29uc3QgcHJvbXB0ID0gRVhUUkFDVElPTl9QUk9NUFRcclxuICAgICAgLnJlcGxhY2UoJ3t7dGl0bGV9fScsIGJpYmxlLnRpdGxlKVxyXG4gICAgICAucmVwbGFjZSgne3tnZW5yZX19JywgYmlibGUuZ2VucmUpXHJcbiAgICAgIC5yZXBsYWNlKCd7e3NldHRpbmd9fScsIGJpYmxlLnNldHRpbmcpXHJcbiAgICAgIC5yZXBsYWNlKCd7e2NoYXB0ZXJOdW1iZXJ9fScsIGNoYXB0ZXIubnVtYmVyLnRvU3RyaW5nKCkpXHJcbiAgICAgIC5yZXBsYWNlKCd7e2NoYXB0ZXJUaXRsZX19JywgY2hhcHRlci50aXRsZSlcclxuICAgICAgLnJlcGxhY2UoJ3t7Y2hhcHRlckNvbnRlbnR9fScsIGNoYXB0ZXIuY29udGVudC5zdWJzdHJpbmcoMCwgODAwMCkpOyAvLyBMaW1pdCBjb250ZW50IGxlbmd0aFxyXG5cclxuICAgIGNvbnN0IHJlc3VsdCA9IGF3YWl0IGdldExMTSgpLmNvbXBsZXRlSlNPTjxFeHRyYWN0aW9uT3V0cHV0Pihwcm9tcHQsIHtcclxuICAgICAgdGVtcGVyYXR1cmU6IDAuMyxcclxuICAgICAgbWF4VG9rZW5zOiAyMDAwLFxyXG4gICAgfSk7XHJcblxyXG4gICAgcmV0dXJuIHJlc3VsdC5tZW1vcmllcyB8fCBbXTtcclxuICB9XHJcblxyXG4gIGFzeW5jIGV4dHJhY3RGcm9tU3VtbWFyeShjaGFwdGVyTnVtYmVyOiBudW1iZXIsIHN1bW1hcnk6IHN0cmluZywgYmlibGU6IFN0b3J5QmlibGUpOiBQcm9taXNlPEV4dHJhY3RlZE1lbW9yeVtdPiB7XHJcbiAgICBjb25zdCBwcm9tcHQgPSBgWW91IGFyZSBhIG5hcnJhdGl2ZSBtZW1vcnkgZXh0cmFjdG9yLiBFeHRyYWN0IGltcG9ydGFudCBmYWN0cyBmcm9tIHRoaXMgY2hhcHRlciBzdW1tYXJ5LlxyXG5cclxuIyMgU3RvcnlcclxuKipUaXRsZToqKiAke2JpYmxlLnRpdGxlfVxyXG4qKkdlbnJlOioqICR7YmlibGUuZ2VucmV9XHJcblxyXG4jIyBDaGFwdGVyICR7Y2hhcHRlck51bWJlcn0gU3VtbWFyeVxyXG4ke3N1bW1hcnl9XHJcblxyXG5FeHRyYWN0IDMtNSBrZXkgbWVtb3JpZXMgKGV2ZW50cywgY2hhcmFjdGVyIG1vbWVudHMsIHdvcmxkIGRldGFpbHMsIHBsb3QgZGV2ZWxvcG1lbnRzKS4gUmVzcG9uZCB3aXRoIEpTT046XHJcbntcclxuICBcIm1lbW9yaWVzXCI6IFtcclxuICAgIHtcImNvbnRlbnRcIjogXCJkZXNjcmlwdGlvbiBvZiB3aGF0IGhhcHBlbmVkXCIsIFwiY2F0ZWdvcnlcIjogXCJldmVudHxjaGFyYWN0ZXJ8d29ybGR8cGxvdFwifVxyXG4gIF1cclxufWA7XHJcblxyXG4gICAgY29uc3QgcmVzdWx0ID0gYXdhaXQgZ2V0TExNKCkuY29tcGxldGVKU09OPEV4dHJhY3Rpb25PdXRwdXQ+KHByb21wdCwge1xyXG4gICAgICB0ZW1wZXJhdHVyZTogMC4zLFxyXG4gICAgICBtYXhUb2tlbnM6IDEwMDAsXHJcbiAgICB9KTtcclxuXHJcbiAgICByZXR1cm4gcmVzdWx0Lm1lbW9yaWVzIHx8IFtdO1xyXG4gIH1cclxufVxyXG5cclxuZXhwb3J0IGNvbnN0IG1lbW9yeUV4dHJhY3RvciA9IG5ldyBNZW1vcnlFeHRyYWN0b3IoKTtcclxuIl19

package/dist/agents/stateUpdater.d.ts

@@ -0,0 +1,30 @@
+import type { Chapter, StoryBible } from '../types/index.js';
+import type { StoryStructuredState } from '../story/structuredState.js';
+interface StateUpdateOutput {
+    characterUpdates: Array<{
+        name: string;
+        emotionalState?: string;
+        location?: string;
+        newKnowledge?: string[];
+        relationshipChanges?: Array<{
+            with: string;
+            status: string;
+        }>;
+        development?: string;
+    }>;
+    plotThreadUpdates: Array<{
+        id: string;
+        status?: 'dormant' | 'active' | 'escalating' | 'resolved';
+        tensionChange?: number;
+        summary?: string;
+    }>;
+    newQuestions: string[];
+    resolvedQuestions: string[];
+    recentEvents: string[];
+}
+export declare class StateUpdater {
+    extractStateChanges(chapter: Chapter, bible: StoryBible, currentState: StoryStructuredState): Promise<StateUpdateOutput>;
+    applyUpdates(state: StoryStructuredState, updates: StateUpdateOutput, chapterNumber: number): StoryStructuredState;
+}
+export declare const stateUpdater: StateUpdater;
+export {};