@narrative-os/engine 0.1.0

package/dist/agents/stateUpdater.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stateUpdater = exports.StateUpdater = void 0;
+const client_js_1 = require("../llm/client.js");
+const STATE_UPDATE_PROMPT = `You are a narrative state tracker. Analyze the chapter and extract state changes.
+
+## Story Bible
+
+**Title:** {{title}}
+**Genre:** {{genre}}
+
+## Characters
+
+{{characters}}
+
+## Current Plot Threads
+
+{{plotThreads}}
+
+## Chapter Content
+
+**Chapter {{chapterNumber}}: {{chapterTitle}}**
+
+{{chapterContent}}
+
+## Current Unresolved Questions
+
+{{unresolvedQuestions}}
+
+## Task
+
+Analyze what changed in this chapter. Output JSON with:
+
+1. **characterUpdates**: How characters changed (emotion, location, knowledge, relationships)
+2. **plotThreadUpdates**: How plot threads progressed (status, tension)
+3. **newQuestions**: New mysteries or questions raised
+4. **resolvedQuestions**: Which current questions were answered
+5. **recentEvents**: Key events that happened (2-3 bullet points)
+
+Example output:
+{
+  "characterUpdates": [
+    {
+      "name": "Alice",
+      "emotionalState": "anxious",
+      "location": "the abandoned warehouse",
+      "newKnowledge": ["the code is 8472"],
+      "relationshipChanges": [{"with": "Bob", "status": "distrustful"}],
+      "development": "Alice realizes she can't trust her mentor"
+    }
+  ],
+  "plotThreadUpdates": [
+    {
+      "id": "missing_brother",
+      "status": "escalating",
+      "tensionChange": 0.1,
+      "summary": "Discovered brother was kidnapped by the syndicate"
+    }
+  ],
+  "newQuestions": ["Who is the mysterious informant?"],
+  "resolvedQuestions": ["Where was the brother taken?"],
+  "recentEvents": ["Alice broke into the warehouse", "Found the hidden room"]
+}`;
+class StateUpdater {
+    async extractStateChanges(chapter, bible, currentState) {
+        const characters = Object.values(currentState.characters)
+            .map(c => `- ${c.name}: currently ${c.emotionalState}, at ${c.location}`)
+            .join('\n') || 'No characters tracked yet.';
+        const plotThreads = Object.values(currentState.plotThreads)
+            .map(t => `- ${t.name} (${t.status}, tension: ${Math.round(t.tension * 100)}%): ${t.summary}`)
+            .join('\n') || 'No active plot threads.';
+        const unresolvedQuestions = currentState.unresolvedQuestions.length > 0
+            ? currentState.unresolvedQuestions.map(q => `- ${q}`).join('\n')
+            : 'None';
+        const prompt = STATE_UPDATE_PROMPT
+            .replace('{{title}}', bible.title)
+            .replace('{{genre}}', bible.genre)
+            .replace('{{characters}}', characters)
+            .replace('{{plotThreads}}', plotThreads)
+            .replace('{{chapterNumber}}', chapter.number.toString())
+            .replace('{{chapterTitle}}', chapter.title)
+            .replace('{{chapterContent}}', chapter.content.substring(0, 6000))
+            .replace('{{unresolvedQuestions}}', unresolvedQuestions);
+        const result = await (0, client_js_1.getLLM)().completeJSON(prompt, {
+            temperature: 0.3,
+            maxTokens: 2000,
+        });
+        return result;
+    }
+    applyUpdates(state, updates, chapterNumber) {
+        let newState = { ...state };
+        // Apply character updates
+        for (const update of updates.characterUpdates) {
+            if (newState.characters[update.name]) {
+                const char = newState.characters[update.name];
+                if (update.emotionalState) {
+                    char.emotionalState = update.emotionalState;
+                }
+                if (update.location) {
+                    char.location = update.location;
+                }
+                if (update.newKnowledge) {
+                    char.knowledge = [...char.knowledge, ...update.newKnowledge];
+                }
+                if (update.relationshipChanges) {
+                    for (const rel of update.relationshipChanges) {
+                        char.relationships[rel.with] = rel.status;
+                    }
+                }
+                if (update.development) {
+                    char.development = [...char.development, update.development];
+                }
+            }
+        }
+        // Apply plot thread updates
+        for (const update of updates.plotThreadUpdates) {
+            if (newState.plotThreads[update.id]) {
+                const thread = newState.plotThreads[update.id];
+                if (update.status) {
+                    thread.status = update.status;
+                }
+                if (update.tensionChange !== undefined) {
+                    thread.tension = Math.max(0, Math.min(1, thread.tension + update.tensionChange));
+                }
+                if (update.summary) {
+                    thread.summary = update.summary;
+                }
+                thread.lastChapter = chapterNumber;
+            }
+        }
+        // Add new questions
+        for (const question of updates.newQuestions) {
+            if (!newState.unresolvedQuestions.includes(question)) {
+                newState.unresolvedQuestions = [...newState.unresolvedQuestions, question];
+            }
+        }
+        // Remove resolved questions
+        for (const question of updates.resolvedQuestions) {
+            newState.unresolvedQuestions = newState.unresolvedQuestions.filter(q => q !== question);
+        }
+        // Add recent events
+        for (const event of updates.recentEvents) {
+            newState.recentEvents = [...newState.recentEvents, event].slice(-10);
+        }
+        return newState;
+    }
+}
+exports.StateUpdater = StateUpdater;
+exports.stateUpdater = new StateUpdater();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stateUpdater.js","sourceRoot":"","sources":["../../src/agents/stateUpdater.ts"],"names":[],"mappings":"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","sourcesContent":["import { getLLM } from '../llm/client.js';\r\nimport type { Chapter, StoryBible } from '../types/index.js';\r\nimport type { StoryStructuredState, CharacterState, PlotThreadState } from '../story/structuredState.js';\r\n\r\ninterface StateUpdateOutput {\r\n  characterUpdates: Array<{\r\n    name: string;\r\n    emotionalState?: string;\r\n    location?: string;\r\n    newKnowledge?: string[];\r\n    relationshipChanges?: Array<{ with: string; status: string }>;\r\n    development?: string;\r\n  }>;\r\n  plotThreadUpdates: Array<{\r\n    id: string;\r\n    status?: 'dormant' | 'active' | 'escalating' | 'resolved';\r\n    tensionChange?: number; // -0.1 to +0.1\r\n    summary?: string;\r\n  }>;\r\n  newQuestions: string[];\r\n  resolvedQuestions: string[];\r\n  recentEvents: string[];\r\n}\r\n\r\nconst STATE_UPDATE_PROMPT = `You are a narrative state tracker. Analyze the chapter and extract state changes.\r\n\r\n## Story Bible\r\n\r\n**Title:** {{title}}\r\n**Genre:** {{genre}}\r\n\r\n## Characters\r\n\r\n{{characters}}\r\n\r\n## Current Plot Threads\r\n\r\n{{plotThreads}}\r\n\r\n## Chapter Content\r\n\r\n**Chapter {{chapterNumber}}: {{chapterTitle}}**\r\n\r\n{{chapterContent}}\r\n\r\n## Current Unresolved Questions\r\n\r\n{{unresolvedQuestions}}\r\n\r\n## Task\r\n\r\nAnalyze what changed in this chapter. Output JSON with:\r\n\r\n1. **characterUpdates**: How characters changed (emotion, location, knowledge, relationships)\r\n2. **plotThreadUpdates**: How plot threads progressed (status, tension)\r\n3. **newQuestions**: New mysteries or questions raised\r\n4. **resolvedQuestions**: Which current questions were answered\r\n5. **recentEvents**: Key events that happened (2-3 bullet points)\r\n\r\nExample output:\r\n{\r\n  \"characterUpdates\": [\r\n    {\r\n      \"name\": \"Alice\",\r\n      \"emotionalState\": \"anxious\",\r\n      \"location\": \"the abandoned warehouse\",\r\n      \"newKnowledge\": [\"the code is 8472\"],\r\n      \"relationshipChanges\": [{\"with\": \"Bob\", \"status\": \"distrustful\"}],\r\n      \"development\": \"Alice realizes she can't trust her mentor\"\r\n    }\r\n  ],\r\n  \"plotThreadUpdates\": [\r\n    {\r\n      \"id\": \"missing_brother\",\r\n      \"status\": \"escalating\",\r\n      \"tensionChange\": 0.1,\r\n      \"summary\": \"Discovered brother was kidnapped by the syndicate\"\r\n    }\r\n  ],\r\n  \"newQuestions\": [\"Who is the mysterious informant?\"],\r\n  \"resolvedQuestions\": [\"Where was the brother taken?\"],\r\n  \"recentEvents\": [\"Alice broke into the warehouse\", \"Found the hidden room\"]\r\n}`;\r\n\r\nexport class StateUpdater {\r\n  async extractStateChanges(\r\n    chapter: Chapter,\r\n    bible: StoryBible,\r\n    currentState: StoryStructuredState\r\n  ): Promise<StateUpdateOutput> {\r\n    const characters = Object.values(currentState.characters)\r\n      .map(c => `- ${c.name}: currently ${c.emotionalState}, at ${c.location}`)\r\n      .join('\\n') || 'No characters tracked yet.';\r\n\r\n    const plotThreads = Object.values(currentState.plotThreads)\r\n      .map(t => `- ${t.name} (${t.status}, tension: ${Math.round(t.tension * 100)}%): ${t.summary}`)\r\n      .join('\\n') || 'No active plot threads.';\r\n\r\n    const unresolvedQuestions = currentState.unresolvedQuestions.length > 0\r\n      ? currentState.unresolvedQuestions.map(q => `- ${q}`).join('\\n')\r\n      : 'None';\r\n\r\n    const prompt = STATE_UPDATE_PROMPT\r\n      .replace('{{title}}', bible.title)\r\n      .replace('{{genre}}', bible.genre)\r\n      .replace('{{characters}}', characters)\r\n      .replace('{{plotThreads}}', plotThreads)\r\n      .replace('{{chapterNumber}}', chapter.number.toString())\r\n      .replace('{{chapterTitle}}', chapter.title)\r\n      .replace('{{chapterContent}}', chapter.content.substring(0, 6000))\r\n      .replace('{{unresolvedQuestions}}', unresolvedQuestions);\r\n\r\n    const result = await getLLM().completeJSON<StateUpdateOutput>(prompt, {\r\n      temperature: 0.3,\r\n      maxTokens: 2000,\r\n    });\r\n\r\n    return result;\r\n  }\r\n\r\n  applyUpdates(\r\n    state: StoryStructuredState,\r\n    updates: StateUpdateOutput,\r\n    chapterNumber: number\r\n  ): StoryStructuredState {\r\n    let newState = { ...state };\r\n\r\n    // Apply character updates\r\n    for (const update of updates.characterUpdates) {\r\n      if (newState.characters[update.name]) {\r\n        const char = newState.characters[update.name];\r\n        \r\n        if (update.emotionalState) {\r\n          char.emotionalState = update.emotionalState;\r\n        }\r\n        if (update.location) {\r\n          char.location = update.location;\r\n        }\r\n        if (update.newKnowledge) {\r\n          char.knowledge = [...char.knowledge, ...update.newKnowledge];\r\n        }\r\n        if (update.relationshipChanges) {\r\n          for (const rel of update.relationshipChanges) {\r\n            char.relationships[rel.with] = rel.status;\r\n          }\r\n        }\r\n        if (update.development) {\r\n          char.development = [...char.development, update.development];\r\n        }\r\n      }\r\n    }\r\n\r\n    // Apply plot thread updates\r\n    for (const update of updates.plotThreadUpdates) {\r\n      if (newState.plotThreads[update.id]) {\r\n        const thread = newState.plotThreads[update.id];\r\n        \r\n        if (update.status) {\r\n          thread.status = update.status;\r\n        }\r\n        if (update.tensionChange !== undefined) {\r\n          thread.tension = Math.max(0, Math.min(1, thread.tension + update.tensionChange));\r\n        }\r\n        if (update.summary) {\r\n          thread.summary = update.summary;\r\n        }\r\n        thread.lastChapter = chapterNumber;\r\n      }\r\n    }\r\n\r\n    // Add new questions\r\n    for (const question of updates.newQuestions) {\r\n      if (!newState.unresolvedQuestions.includes(question)) {\r\n        newState.unresolvedQuestions = [...newState.unresolvedQuestions, question];\r\n      }\r\n    }\r\n\r\n    // Remove resolved questions\r\n    for (const question of updates.resolvedQuestions) {\r\n      newState.unresolvedQuestions = newState.unresolvedQuestions.filter(q => q !== question);\r\n    }\r\n\r\n    // Add recent events\r\n    for (const event of updates.recentEvents) {\r\n      newState.recentEvents = [...newState.recentEvents, event].slice(-10);\r\n    }\r\n\r\n    return newState;\r\n  }\r\n}\r\n\r\nexport const stateUpdater = new StateUpdater();\r\n"]}

package/dist/agents/storyDirector.d.ts

@@ -0,0 +1,40 @@
+import type { StoryBible, StoryState, ChapterSummary } from '../types/index.js';
+import type { StoryStructuredState } from '../story/structuredState.js';
+import type { TensionGuidance } from './tensionController.js';
+export interface ChapterObjective {
+    id: string;
+    description: string;
+    priority: 'critical' | 'high' | 'medium' | 'low';
+    type: 'plot' | 'character' | 'world' | 'tension' | 'resolution';
+    relatedPlotThreadId?: string;
+    relatedCharacter?: string;
+}
+export interface DirectorOutput {
+    chapterNumber: number;
+    overallGoal: string;
+    objectives: ChapterObjective[];
+    focusCharacters: string[];
+    suggestedScenes: string[];
+    tone: string;
+    notes: string;
+}
+export interface DirectorContext {
+    bible: StoryBible;
+    state: StoryState;
+    structuredState: StoryStructuredState;
+    tensionGuidance: TensionGuidance;
+    previousSummaries: ChapterSummary[];
+}
+export declare class StoryDirector {
+    direct(context: DirectorContext): Promise<DirectorOutput>;
+    private buildPrompt;
+    /**
+     * Format director output for writer prompt
+     */
+    formatForPrompt(output: DirectorOutput): string;
+    /**
+     * Get quick objectives without LLM call (for testing/fallback)
+     */
+    generateFallbackObjectives(state: StoryState, structuredState: StoryStructuredState): DirectorOutput;
+}
+export declare const storyDirector: StoryDirector;

package/dist/agents/storyDirector.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storyDirector = exports.StoryDirector = void 0;
+const client_js_1 = require("../llm/client.js");
+const STORY_DIRECTOR_PROMPT = `You are the Story Director for a narrative AI system. Your job is to decide what the next chapter should accomplish.
+
+## Story Bible
+
+**Title:** {{title}}
+**Genre:** {{genre}}
+**Theme:** {{theme}}
+**Premise:** {{premise}}
+
+## Current Story State
+
+**Chapter:** {{currentChapter}} / {{totalChapters}}
+**Story Tension:** {{storyTension}}%
+**Target Tension:** {{targetTension}}%
+
+### Active Plot Threads
+{{plotThreads}}
+
+### Character States
+{{characters}}
+
+### Unresolved Questions
+{{questions}}
+
+### Recent Events
+{{recentEvents}}
+
+## Tension Guidance
+
+{{tensionGuidance}}
+
+## Previous Chapter Summaries
+{{summaries}}
+
+## Your Task
+
+Based on all the above information, decide what Chapter {{nextChapter}} should accomplish. Consider:
+
+1. **Plot Progression**: Which plot threads need advancement?
+2. **Character Development**: Which characters need focus or growth?
+3. **Tension Management**: How should tension change based on target?
+4. **Unresolved Questions**: Which mysteries should be addressed?
+5. **Story Arc**: Where are we in the overall narrative (setup/rising action/climax/resolution)?
+
+Output a JSON object with:
+
+{
+  "chapterNumber": {{nextChapter}},
+  "overallGoal": "One-sentence description of what this chapter achieves",
+  "objectives": [
+    {
+      "id": "unique-id",
+      "description": "What needs to happen",
+      "priority": "critical|high|medium|low",
+      "type": "plot|character|world|tension|resolution",
+      "relatedPlotThreadId": "thread-id or omit",
+      "relatedCharacter": "character name or omit"
+    }
+  ],
+  "focusCharacters": ["Character names that should be central"],
+  "suggestedScenes": ["Scene ideas that could achieve objectives"],
+  "tone": "emotional tone for this chapter",
+  "notes": "Additional guidance for the writer"
+}
+
+Be specific and actionable. The writer will use your direction to craft the chapter.`;
+class StoryDirector {
+    async direct(context) {
+        const { bible, state, structuredState, tensionGuidance, previousSummaries } = context;
+        const prompt = this.buildPrompt(bible, state, structuredState, tensionGuidance, previousSummaries);
+        const result = await (0, client_js_1.getLLM)().completeJSON(prompt, {
+            temperature: 0.4,
+            maxTokens: 2000,
+        });
+        return result;
+    }
+    buildPrompt(bible, state, structuredState, tensionGuidance, summaries) {
+        const currentTension = Math.round(structuredState.tension * 100);
+        const targetTension = Math.round(tensionGuidance.targetTension * 100);
+        // Format plot threads
+        const activeThreads = Object.values(structuredState.plotThreads)
+            .filter(t => t.status !== 'resolved')
+            .map(t => `- **${t.name}** (${t.status}, ${Math.round(t.tension * 100)}% tension): ${t.summary}`)
+            .join('\n') || 'No active plot threads.';
+        // Format characters
+        const characters = Object.values(structuredState.characters)
+            .map(c => `- **${c.name}**: ${c.emotionalState}, at ${c.location}`)
+            .join('\n') || 'No character data.';
+        // Format questions
+        const questions = structuredState.unresolvedQuestions.length > 0
+            ? structuredState.unresolvedQuestions.map(q => `- ${q}`).join('\n')
+            : 'None';
+        // Format recent events
+        const recentEvents = structuredState.recentEvents.length > 0
+            ? structuredState.recentEvents.slice(-5).map(e => `- ${e}`).join('\n')
+            : 'None';
+        // Format tension guidance
+        const tensionText = `Target: ${targetTension}%
+Guidance: ${tensionGuidance.guidance}
+Scene Types: ${tensionGuidance.sceneTypes.join(', ')}
+Pacing: ${tensionGuidance.pacingNotes}`;
+        // Format summaries (last 3)
+        const recentSummaries = summaries.slice(-3);
+        const summariesText = recentSummaries.length > 0
+            ? recentSummaries.map(s => `Chapter ${s.chapterNumber}: ${s.summary}`).join('\n')
+            : 'No previous chapters.';
+        return STORY_DIRECTOR_PROMPT
+            .replace('{{title}}', bible.title)
+            .replace('{{genre}}', bible.genre)
+            .replace('{{theme}}', bible.theme)
+            .replace('{{premise}}', bible.premise)
+            .replace('{{currentChapter}}', state.currentChapter.toString())
+            .replace('{{totalChapters}}', state.totalChapters.toString())
+            .replace('{{storyTension}}', currentTension.toString())
+            .replace('{{targetTension}}', targetTension.toString())
+            .replace('{{plotThreads}}', activeThreads)
+            .replace('{{characters}}', characters)
+            .replace('{{questions}}', questions)
+            .replace('{{recentEvents}}', recentEvents)
+            .replace('{{tensionGuidance}}', tensionText)
+            .replace('{{summaries}}', summariesText)
+            .replace(/{{nextChapter}}/g, (state.currentChapter + 1).toString());
+    }
+    /**
+     * Format director output for writer prompt
+     */
+    formatForPrompt(output) {
+        const lines = ['## Chapter Direction'];
+        lines.push(`\n**Chapter ${output.chapterNumber} Goal:** ${output.overallGoal}`);
+        lines.push(`\n**Tone:** ${output.tone}`);
+        if (output.focusCharacters.length > 0) {
+            lines.push(`\n**Focus Characters:** ${output.focusCharacters.join(', ')}`);
+        }
+        if (output.objectives.length > 0) {
+            lines.push('\n**Objectives (in priority order):**');
+            const sorted = [...output.objectives].sort((a, b) => {
+                const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+                return priorityOrder[a.priority] - priorityOrder[b.priority];
+            });
+            for (const obj of sorted) {
+                const emoji = { critical: '🔴', high: '🟠', medium: '🟡', low: '🟢' }[obj.priority];
+                lines.push(`${emoji} **[${obj.type.toUpperCase()}]** ${obj.description}`);
+            }
+        }
+        if (output.suggestedScenes.length > 0) {
+            lines.push('\n**Suggested Scenes:**');
+            for (const scene of output.suggestedScenes) {
+                lines.push(`- ${scene}`);
+            }
+        }
+        if (output.notes) {
+            lines.push(`\n**Director's Notes:** ${output.notes}`);
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Get quick objectives without LLM call (for testing/fallback)
+     */
+    generateFallbackObjectives(state, structuredState) {
+        const nextChapter = state.currentChapter + 1;
+        const objectives = [];
+        // Add plot thread objectives
+        const activeThreads = Object.values(structuredState.plotThreads)
+            .filter(t => t.status === 'active' || t.status === 'escalating');
+        for (const thread of activeThreads.slice(0, 2)) {
+            objectives.push({
+                id: `plot-${thread.id}`,
+                description: `Advance the "${thread.name}" plot thread`,
+                priority: 'high',
+                type: 'plot',
+                relatedPlotThreadId: thread.id,
+            });
+        }
+        // Add character objective
+        const characters = Object.values(structuredState.characters);
+        if (characters.length > 0) {
+            const char = characters[nextChapter % characters.length];
+            objectives.push({
+                id: `char-${char.name}`,
+                description: `Develop ${char.name}'s character arc`,
+                priority: 'medium',
+                type: 'character',
+                relatedCharacter: char.name,
+            });
+        }
+        // Add tension objective if needed
+        const targetTension = 4 * (nextChapter / state.totalChapters) * (1 - nextChapter / state.totalChapters);
+        if (structuredState.tension < targetTension - 0.2) {
+            objectives.push({
+                id: 'tension-escalate',
+                description: 'Escalate tension toward target level',
+                priority: 'high',
+                type: 'tension',
+            });
+        }
+        return {
+            chapterNumber: nextChapter,
+            overallGoal: `Advance the story toward chapter ${nextChapter} with focus on active plot threads`,
+            objectives,
+            focusCharacters: characters.slice(0, 2).map(c => c.name),
+            suggestedScenes: ['Opening scene establishing current situation', 'Development of main plot thread', 'Character interaction moment'],
+            tone: 'dramatic',
+            notes: 'Auto-generated objectives based on current story state',
+        };
+    }
+}
+exports.StoryDirector = StoryDirector;
+exports.storyDirector = new StoryDirector();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storyDirector.js","sourceRoot":"","sources":["../../src/agents/storyDirector.ts"],"names":[],"mappings":"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","sourcesContent":["import { getLLM } from '../llm/client.js';\r\nimport type { StoryBible, StoryState, ChapterSummary } from '../types/index.js';\r\nimport type { StoryStructuredState } from '../story/structuredState.js';\r\nimport type { TensionGuidance } from './tensionController.js';\r\n\r\nexport interface ChapterObjective {\r\n  id: string;\r\n  description: string;\r\n  priority: 'critical' | 'high' | 'medium' | 'low';\r\n  type: 'plot' | 'character' | 'world' | 'tension' | 'resolution';\r\n  relatedPlotThreadId?: string;\r\n  relatedCharacter?: string;\r\n}\r\n\r\nexport interface DirectorOutput {\r\n  chapterNumber: number;\r\n  overallGoal: string;\r\n  objectives: ChapterObjective[];\r\n  focusCharacters: string[];\r\n  suggestedScenes: string[];\r\n  tone: string;\r\n  notes: string;\r\n}\r\n\r\nexport interface DirectorContext {\r\n  bible: StoryBible;\r\n  state: StoryState;\r\n  structuredState: StoryStructuredState;\r\n  tensionGuidance: TensionGuidance;\r\n  previousSummaries: ChapterSummary[];\r\n}\r\n\r\nconst STORY_DIRECTOR_PROMPT = `You are the Story Director for a narrative AI system. Your job is to decide what the next chapter should accomplish.\r\n\r\n## Story Bible\r\n\r\n**Title:** {{title}}\r\n**Genre:** {{genre}}\r\n**Theme:** {{theme}}\r\n**Premise:** {{premise}}\r\n\r\n## Current Story State\r\n\r\n**Chapter:** {{currentChapter}} / {{totalChapters}}\r\n**Story Tension:** {{storyTension}}%\r\n**Target Tension:** {{targetTension}}%\r\n\r\n### Active Plot Threads\r\n{{plotThreads}}\r\n\r\n### Character States\r\n{{characters}}\r\n\r\n### Unresolved Questions\r\n{{questions}}\r\n\r\n### Recent Events\r\n{{recentEvents}}\r\n\r\n## Tension Guidance\r\n\r\n{{tensionGuidance}}\r\n\r\n## Previous Chapter Summaries\r\n{{summaries}}\r\n\r\n## Your Task\r\n\r\nBased on all the above information, decide what Chapter {{nextChapter}} should accomplish. Consider:\r\n\r\n1. **Plot Progression**: Which plot threads need advancement?\r\n2. **Character Development**: Which characters need focus or growth?\r\n3. **Tension Management**: How should tension change based on target?\r\n4. **Unresolved Questions**: Which mysteries should be addressed?\r\n5. **Story Arc**: Where are we in the overall narrative (setup/rising action/climax/resolution)?\r\n\r\nOutput a JSON object with:\r\n\r\n{\r\n  \"chapterNumber\": {{nextChapter}},\r\n  \"overallGoal\": \"One-sentence description of what this chapter achieves\",\r\n  \"objectives\": [\r\n    {\r\n      \"id\": \"unique-id\",\r\n      \"description\": \"What needs to happen\",\r\n      \"priority\": \"critical|high|medium|low\",\r\n      \"type\": \"plot|character|world|tension|resolution\",\r\n      \"relatedPlotThreadId\": \"thread-id or omit\",\r\n      \"relatedCharacter\": \"character name or omit\"\r\n    }\r\n  ],\r\n  \"focusCharacters\": [\"Character names that should be central\"],\r\n  \"suggestedScenes\": [\"Scene ideas that could achieve objectives\"],\r\n  \"tone\": \"emotional tone for this chapter\",\r\n  \"notes\": \"Additional guidance for the writer\"\r\n}\r\n\r\nBe specific and actionable. The writer will use your direction to craft the chapter.`;\r\n\r\nexport class StoryDirector {\r\n  async direct(context: DirectorContext): Promise<DirectorOutput> {\r\n    const { bible, state, structuredState, tensionGuidance, previousSummaries } = context;\r\n    \r\n    const prompt = this.buildPrompt(bible, state, structuredState, tensionGuidance, previousSummaries);\r\n    \r\n    const result = await getLLM().completeJSON<DirectorOutput>(prompt, {\r\n      temperature: 0.4,\r\n      maxTokens: 2000,\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    tensionGuidance: TensionGuidance,\r\n    summaries: ChapterSummary[]\r\n  ): string {\r\n    const currentTension = Math.round(structuredState.tension * 100);\r\n    const targetTension = Math.round(tensionGuidance.targetTension * 100);\r\n    \r\n    // Format plot threads\r\n    const activeThreads = 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): ${t.summary}`)\r\n      .join('\\n') || 'No active plot threads.';\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 questions\r\n    const questions = structuredState.unresolvedQuestions.length > 0\r\n      ? structuredState.unresolvedQuestions.map(q => `- ${q}`).join('\\n')\r\n      : 'None';\r\n    \r\n    // Format recent events\r\n    const recentEvents = structuredState.recentEvents.length > 0\r\n      ? structuredState.recentEvents.slice(-5).map(e => `- ${e}`).join('\\n')\r\n      : 'None';\r\n    \r\n    // Format tension guidance\r\n    const tensionText = `Target: ${targetTension}%\r\nGuidance: ${tensionGuidance.guidance}\r\nScene Types: ${tensionGuidance.sceneTypes.join(', ')}\r\nPacing: ${tensionGuidance.pacingNotes}`;\r\n    \r\n    // Format summaries (last 3)\r\n    const recentSummaries = summaries.slice(-3);\r\n    const summariesText = recentSummaries.length > 0\r\n      ? recentSummaries.map(s => `Chapter ${s.chapterNumber}: ${s.summary}`).join('\\n')\r\n      : 'No previous chapters.';\r\n    \r\n    return STORY_DIRECTOR_PROMPT\r\n      .replace('{{title}}', bible.title)\r\n      .replace('{{genre}}', bible.genre)\r\n      .replace('{{theme}}', bible.theme)\r\n      .replace('{{premise}}', bible.premise)\r\n      .replace('{{currentChapter}}', state.currentChapter.toString())\r\n      .replace('{{totalChapters}}', state.totalChapters.toString())\r\n      .replace('{{storyTension}}', currentTension.toString())\r\n      .replace('{{targetTension}}', targetTension.toString())\r\n      .replace('{{plotThreads}}', activeThreads)\r\n      .replace('{{characters}}', characters)\r\n      .replace('{{questions}}', questions)\r\n      .replace('{{recentEvents}}', recentEvents)\r\n      .replace('{{tensionGuidance}}', tensionText)\r\n      .replace('{{summaries}}', summariesText)\r\n      .replace(/{{nextChapter}}/g, (state.currentChapter + 1).toString());\r\n  }\r\n  \r\n  /**\r\n   * Format director output for writer prompt\r\n   */\r\n  formatForPrompt(output: DirectorOutput): string {\r\n    const lines: string[] = ['## Chapter Direction'];\r\n    \r\n    lines.push(`\\n**Chapter ${output.chapterNumber} Goal:** ${output.overallGoal}`);\r\n    lines.push(`\\n**Tone:** ${output.tone}`);\r\n    \r\n    if (output.focusCharacters.length > 0) {\r\n      lines.push(`\\n**Focus Characters:** ${output.focusCharacters.join(', ')}`);\r\n    }\r\n    \r\n    if (output.objectives.length > 0) {\r\n      lines.push('\\n**Objectives (in priority order):**');\r\n      const sorted = [...output.objectives].sort((a, b) => {\r\n        const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };\r\n        return priorityOrder[a.priority] - priorityOrder[b.priority];\r\n      });\r\n      \r\n      for (const obj of sorted) {\r\n        const emoji = { critical: '🔴', high: '🟠', medium: '🟡', low: '🟢' }[obj.priority];\r\n        lines.push(`${emoji} **[${obj.type.toUpperCase()}]** ${obj.description}`);\r\n      }\r\n    }\r\n    \r\n    if (output.suggestedScenes.length > 0) {\r\n      lines.push('\\n**Suggested Scenes:**');\r\n      for (const scene of output.suggestedScenes) {\r\n        lines.push(`- ${scene}`);\r\n      }\r\n    }\r\n    \r\n    if (output.notes) {\r\n      lines.push(`\\n**Director's Notes:** ${output.notes}`);\r\n    }\r\n    \r\n    return lines.join('\\n');\r\n  }\r\n  \r\n  /**\r\n   * Get quick objectives without LLM call (for testing/fallback)\r\n   */\r\n  generateFallbackObjectives(\r\n    state: StoryState,\r\n    structuredState: StoryStructuredState\r\n  ): DirectorOutput {\r\n    const nextChapter = state.currentChapter + 1;\r\n    const objectives: ChapterObjective[] = [];\r\n    \r\n    // Add plot thread objectives\r\n    const activeThreads = Object.values(structuredState.plotThreads)\r\n      .filter(t => t.status === 'active' || t.status === 'escalating');\r\n    \r\n    for (const thread of activeThreads.slice(0, 2)) {\r\n      objectives.push({\r\n        id: `plot-${thread.id}`,\r\n        description: `Advance the \"${thread.name}\" plot thread`,\r\n        priority: 'high',\r\n        type: 'plot',\r\n        relatedPlotThreadId: thread.id,\r\n      });\r\n    }\r\n    \r\n    // Add character objective\r\n    const characters = Object.values(structuredState.characters);\r\n    if (characters.length > 0) {\r\n      const char = characters[nextChapter % characters.length];\r\n      objectives.push({\r\n        id: `char-${char.name}`,\r\n        description: `Develop ${char.name}'s character arc`,\r\n        priority: 'medium',\r\n        type: 'character',\r\n        relatedCharacter: char.name,\r\n      });\r\n    }\r\n    \r\n    // Add tension objective if needed\r\n    const targetTension = 4 * (nextChapter / state.totalChapters) * (1 - nextChapter / state.totalChapters);\r\n    if (structuredState.tension < targetTension - 0.2) {\r\n      objectives.push({\r\n        id: 'tension-escalate',\r\n        description: 'Escalate tension toward target level',\r\n        priority: 'high',\r\n        type: 'tension',\r\n      });\r\n    }\r\n    \r\n    return {\r\n      chapterNumber: nextChapter,\r\n      overallGoal: `Advance the story toward chapter ${nextChapter} with focus on active plot threads`,\r\n      objectives,\r\n      focusCharacters: characters.slice(0, 2).map(c => c.name),\r\n      suggestedScenes: ['Opening scene establishing current situation', 'Development of main plot thread', 'Character interaction moment'],\r\n      tone: 'dramatic',\r\n      notes: 'Auto-generated objectives based on current story state',\r\n    };\r\n  }\r\n}\r\n\r\nexport const storyDirector = new StoryDirector();\r\n"]}

package/dist/agents/summarizer.d.ts

@@ -0,0 +1,8 @@
+import type { ChapterSummary } from '../types/index.js';
+export declare class ChapterSummarizer {
+    private promptTemplate;
+    constructor();
+    summarize(chapterText: string, chapterNumber: number): Promise<ChapterSummary>;
+    private extractKeyEvents;
+}
+export declare const summarizer: ChapterSummarizer;

package/dist/agents/summarizer.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizer = exports.ChapterSummarizer = void 0;
+const client_js_1 = require("../llm/client.js");
+const SUMMARIZER_PROMPT = `Summarize the following chapter in under 120 tokens.
+
+Focus on:
+- Major events that occurred
+- Plot progress made
+- Important character changes or revelations
+
+## Chapter Text
+
+{{chapterText}}
+
+## Summary`;
+class ChapterSummarizer {
+    promptTemplate;
+    constructor() {
+        this.promptTemplate = SUMMARIZER_PROMPT;
+    }
+    async summarize(chapterText, chapterNumber) {
+        const prompt = this.promptTemplate.replace('{{chapterText}}', chapterText);
+        const summary = await (0, client_js_1.getLLM)().complete(prompt, {
+            temperature: 0.3,
+            maxTokens: 200,
+        });
+        return {
+            chapterNumber,
+            summary: summary.trim(),
+            keyEvents: this.extractKeyEvents(chapterText),
+            characterChanges: {},
+        };
+    }
+    extractKeyEvents(text) {
+        const sentences = text.match(/[^.!?]+[.!?]+/g) || [];
+        const events = [];
+        for (const sentence of sentences.slice(0, 20)) {
+            const lower = sentence.toLowerCase();
+            if (lower.includes('discovered') ||
+                lower.includes('realized') ||
+                lower.includes('decided') ||
+                lower.includes('arrived') ||
+                lower.includes('found') ||
+                lower.includes('learned')) {
+                events.push(sentence.trim());
+            }
+            if (events.length >= 3)
+                break;
+        }
+        return events;
+    }
+}
+exports.ChapterSummarizer = ChapterSummarizer;
+exports.summarizer = new ChapterSummarizer();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3VtbWFyaXplci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hZ2VudHMvc3VtbWFyaXplci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxnREFBMEM7QUFHMUMsTUFBTSxpQkFBaUIsR0FBRzs7Ozs7Ozs7Ozs7V0FXZixDQUFDO0FBRVosTUFBYSxpQkFBaUI7SUFDcEIsY0FBYyxDQUFTO0lBRS9CO1FBQ0UsSUFBSSxDQUFDLGNBQWMsR0FBRyxpQkFBaUIsQ0FBQztJQUMxQyxDQUFDO0lBRUQsS0FBSyxDQUFDLFNBQVMsQ0FBQyxXQUFtQixFQUFFLGFBQXFCO1FBQ3hELE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxjQUFjLENBQUMsT0FBTyxDQUFDLGlCQUFpQixFQUFFLFdBQVcsQ0FBQyxDQUFDO1FBRTNFLE1BQU0sT0FBTyxHQUFHLE1BQU0sSUFBQSxrQkFBTSxHQUFFLENBQUMsUUFBUSxDQUFDLE1BQU0sRUFBRTtZQUM5QyxXQUFXLEVBQUUsR0FBRztZQUNoQixTQUFTLEVBQUUsR0FBRztTQUNmLENBQUMsQ0FBQztRQUVILE9BQU87WUFDTCxhQUFhO1lBQ2IsT0FBTyxFQUFFLE9BQU8sQ0FBQyxJQUFJLEVBQUU7WUFDdkIsU0FBUyxFQUFFLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxXQUFXLENBQUM7WUFDN0MsZ0JBQWdCLEVBQUUsRUFBRTtTQUNyQixDQUFDO0lBQ0osQ0FBQztJQUVPLGdCQUFnQixDQUFDLElBQVk7UUFDbkMsTUFBTSxTQUFTLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNyRCxNQUFNLE1BQU0sR0FBYSxFQUFFLENBQUM7UUFFNUIsS0FBSyxNQUFNLFFBQVEsSUFBSSxTQUFTLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsRUFBRSxDQUFDO1lBQzlDLE1BQU0sS0FBSyxHQUFHLFFBQVEsQ0FBQyxXQUFXLEVBQUUsQ0FBQztZQUNyQyxJQUNFLEtBQUssQ0FBQyxRQUFRLENBQUMsWUFBWSxDQUFDO2dCQUM1QixLQUFLLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQztnQkFDMUIsS0FBSyxDQUFDLFFBQVEsQ0FBQyxTQUFTLENBQUM7Z0JBQ3pCLEtBQUssQ0FBQyxRQUFRLENBQUMsU0FBUyxDQUFDO2dCQUN6QixLQUFLLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQztnQkFDdkIsS0FBSyxDQUFDLFFBQVEsQ0FBQyxTQUFTLENBQUMsRUFDekIsQ0FBQztnQkFDRCxNQUFNLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDO1lBQy9CLENBQUM7WUFDRCxJQUFJLE1BQU0sQ0FBQyxNQUFNLElBQUksQ0FBQztnQkFBRSxNQUFNO1FBQ2hDLENBQUM7UUFFRCxPQUFPLE1BQU0sQ0FBQztJQUNoQixDQUFDO0NBQ0Y7QUE1Q0QsOENBNENDO0FBRVksUUFBQSxVQUFVLEdBQUcsSUFBSSxpQkFBaUIsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZ2V0TExNIH0gZnJvbSAnLi4vbGxtL2NsaWVudC5qcyc7XHJcbmltcG9ydCB0eXBlIHsgQ2hhcHRlclN1bW1hcnkgfSBmcm9tICcuLi90eXBlcy9pbmRleC5qcyc7XHJcblxyXG5jb25zdCBTVU1NQVJJWkVSX1BST01QVCA9IGBTdW1tYXJpemUgdGhlIGZvbGxvd2luZyBjaGFwdGVyIGluIHVuZGVyIDEyMCB0b2tlbnMuXHJcblxyXG5Gb2N1cyBvbjpcclxuLSBNYWpvciBldmVudHMgdGhhdCBvY2N1cnJlZFxyXG4tIFBsb3QgcHJvZ3Jlc3MgbWFkZVxyXG4tIEltcG9ydGFudCBjaGFyYWN0ZXIgY2hhbmdlcyBvciByZXZlbGF0aW9uc1xyXG5cclxuIyMgQ2hhcHRlciBUZXh0XHJcblxyXG57e2NoYXB0ZXJUZXh0fX1cclxuXHJcbiMjIFN1bW1hcnlgO1xyXG5cclxuZXhwb3J0IGNsYXNzIENoYXB0ZXJTdW1tYXJpemVyIHtcclxuICBwcml2YXRlIHByb21wdFRlbXBsYXRlOiBzdHJpbmc7XHJcblxyXG4gIGNvbnN0cnVjdG9yKCkge1xyXG4gICAgdGhpcy5wcm9tcHRUZW1wbGF0ZSA9IFNVTU1BUklaRVJfUFJPTVBUO1xyXG4gIH1cclxuXHJcbiAgYXN5bmMgc3VtbWFyaXplKGNoYXB0ZXJUZXh0OiBzdHJpbmcsIGNoYXB0ZXJOdW1iZXI6IG51bWJlcik6IFByb21pc2U8Q2hhcHRlclN1bW1hcnk+IHtcclxuICAgIGNvbnN0IHByb21wdCA9IHRoaXMucHJvbXB0VGVtcGxhdGUucmVwbGFjZSgne3tjaGFwdGVyVGV4dH19JywgY2hhcHRlclRleHQpO1xyXG5cclxuICAgIGNvbnN0IHN1bW1hcnkgPSBhd2FpdCBnZXRMTE0oKS5jb21wbGV0ZShwcm9tcHQsIHtcclxuICAgICAgdGVtcGVyYXR1cmU6IDAuMyxcclxuICAgICAgbWF4VG9rZW5zOiAyMDAsXHJcbiAgICB9KTtcclxuXHJcbiAgICByZXR1cm4ge1xyXG4gICAgICBjaGFwdGVyTnVtYmVyLFxyXG4gICAgICBzdW1tYXJ5OiBzdW1tYXJ5LnRyaW0oKSxcclxuICAgICAga2V5RXZlbnRzOiB0aGlzLmV4dHJhY3RLZXlFdmVudHMoY2hhcHRlclRleHQpLFxyXG4gICAgICBjaGFyYWN0ZXJDaGFuZ2VzOiB7fSxcclxuICAgIH07XHJcbiAgfVxyXG5cclxuICBwcml2YXRlIGV4dHJhY3RLZXlFdmVudHModGV4dDogc3RyaW5nKTogc3RyaW5nW10ge1xyXG4gICAgY29uc3Qgc2VudGVuY2VzID0gdGV4dC5tYXRjaCgvW14uIT9dK1suIT9dKy9nKSB8fCBbXTtcclxuICAgIGNvbnN0IGV2ZW50czogc3RyaW5nW10gPSBbXTtcclxuICAgIFxyXG4gICAgZm9yIChjb25zdCBzZW50ZW5jZSBvZiBzZW50ZW5jZXMuc2xpY2UoMCwgMjApKSB7XHJcbiAgICAgIGNvbnN0IGxvd2VyID0gc2VudGVuY2UudG9Mb3dlckNhc2UoKTtcclxuICAgICAgaWYgKFxyXG4gICAgICAgIGxvd2VyLmluY2x1ZGVzKCdkaXNjb3ZlcmVkJykgfHxcclxuICAgICAgICBsb3dlci5pbmNsdWRlcygncmVhbGl6ZWQnKSB8fFxyXG4gICAgICAgIGxvd2VyLmluY2x1ZGVzKCdkZWNpZGVkJykgfHxcclxuICAgICAgICBsb3dlci5pbmNsdWRlcygnYXJyaXZlZCcpIHx8XHJcbiAgICAgICAgbG93ZXIuaW5jbHVkZXMoJ2ZvdW5kJykgfHxcclxuICAgICAgICBsb3dlci5pbmNsdWRlcygnbGVhcm5lZCcpXHJcbiAgICAgICkge1xyXG4gICAgICAgIGV2ZW50cy5wdXNoKHNlbnRlbmNlLnRyaW0oKSk7XHJcbiAgICAgIH1cclxuICAgICAgaWYgKGV2ZW50cy5sZW5ndGggPj0gMykgYnJlYWs7XHJcbiAgICB9XHJcbiAgICBcclxuICAgIHJldHVybiBldmVudHM7XHJcbiAgfVxyXG59XHJcblxyXG5leHBvcnQgY29uc3Qgc3VtbWFyaXplciA9IG5ldyBDaGFwdGVyU3VtbWFyaXplcigpO1xyXG4iXX0=

package/dist/agents/tensionController.d.ts

@@ -0,0 +1,68 @@
+import type { Chapter, StoryState } from '../types/index.js';
+import type { StoryStructuredState } from '../story/structuredState.js';
+export interface TensionAnalysis {
+    currentTension: number;
+    targetTension: number;
+    tensionGap: number;
+    recommendedAction: 'escalate' | 'maintain' | 'resolve' | 'climax';
+    reasoning: string;
+}
+export interface TensionGuidance {
+    targetTension: number;
+    guidance: string;
+    sceneTypes: string[];
+    pacingNotes: string;
+}
+/**
+ * Calculate target tension using parabolic curve
+ * Formula: targetTension = 4 * progress * (1 - progress)
+ *
+ * This creates a natural dramatic arc:
+ * - Chapter 0: 0% tension (setup)
+ * - Middle chapters: ~100% tension (peak drama)
+ * - Final chapter: 0% tension (resolution)
+ */
+export declare function calculateTargetTension(currentChapter: number, totalChapters: number): number;
+/**
+ * Calculate tension for next chapter based on ideal arc
+ */
+export declare function calculateNextChapterTension(currentChapter: number, totalChapters: number): number;
+/**
+ * Analyze current tension vs target and provide guidance
+ */
+export declare function analyzeTension(storyState: StoryState, structuredState: StoryStructuredState): TensionAnalysis;
+/**
+ * Generate tension guidance for the writer
+ */
+export declare function generateTensionGuidance(analysis: TensionAnalysis, storyState: StoryState): TensionGuidance;
+/**
+ * Format tension guidance for writer prompt
+ */
+export declare function formatTensionForPrompt(guidance: TensionGuidance): string;
+/**
+ * Calculate tension based on chapter content analysis
+ * This is a heuristic for estimating tension from text
+ */
+export declare function estimateTensionFromChapter(chapter: Chapter): number;
+/**
+ * TensionController class for managing story tension
+ */
+export declare class TensionController {
+    /**
+     * Analyze current story state and provide tension guidance
+     */
+    analyze(storyState: StoryState, structuredState: StoryStructuredState): TensionAnalysis;
+    /**
+     * Generate guidance for the next chapter
+     */
+    generateGuidance(storyState: StoryState, structuredState: StoryStructuredState): TensionGuidance;
+    /**
+     * Calculate what the tension should be for a specific chapter
+     */
+    calculateTarget(chapterNumber: number, totalChapters: number): number;
+    /**
+     * Estimate tension from chapter content
+     */
+    estimateFromContent(chapter: Chapter): number;
+}
+export declare const tensionController: TensionController;