@narrative-os/engine 0.1.0

package/dist/world/characterAgent.d.ts

@@ -0,0 +1,73 @@
+import type { CharacterState } from '../story/structuredState.js';
+export interface CharacterAgent {
+    name: string;
+    goals: string[];
+    currentGoal: string;
+    location: string;
+    knowledge: string[];
+    relationships: Record<string, string>;
+    personality: string[];
+    emotionalState: string;
+    inventory: string[];
+    agenda: AgendaItem[];
+}
+export interface AgendaItem {
+    id: string;
+    action: string;
+    priority: number;
+    deadline?: number;
+    completed: boolean;
+}
+export interface CharacterDecision {
+    character: string;
+    action: string;
+    target?: string;
+    reasoning: string;
+    consequences: string[];
+}
+export interface CharacterAgentContext {
+    character: CharacterAgent;
+    otherCharacters: CharacterAgent[];
+    worldEvents: string[];
+    currentChapter: number;
+    storyContext: string;
+}
+export declare class CharacterAgentSystem {
+    /**
+     * Create a character agent from structured state
+     */
+    createAgent(characterState: CharacterState, personality: string[]): CharacterAgent;
+    /**
+     * Add an agenda item for a character
+     */
+    addAgendaItem(agent: CharacterAgent, action: string, priority?: number, deadline?: number): CharacterAgent;
+    /**
+     * Complete an agenda item
+     */
+    completeAgendaItem(agent: CharacterAgent, agendaId: string): CharacterAgent;
+    /**
+     * Update character knowledge
+     */
+    addKnowledge(agent: CharacterAgent, fact: string): CharacterAgent;
+    /**
+     * Update relationship
+     */
+    updateRelationship(agent: CharacterAgent, otherCharacter: string, relationship: string): CharacterAgent;
+    /**
+     * Move character to new location
+     */
+    moveTo(agent: CharacterAgent, location: string): CharacterAgent;
+    /**
+     * Get character decision using LLM
+     */
+    getDecision(context: CharacterAgentContext): Promise<CharacterDecision>;
+    /**
+     * Get simple decision without LLM (for testing/fallback)
+     */
+    getSimpleDecision(context: CharacterAgentContext): CharacterDecision;
+    /**
+     * Simulate multiple characters making decisions
+     */
+    simulateTurn(agents: CharacterAgent[], worldEvents: string[], currentChapter: number, storyContext: string, useLLM?: boolean): Promise<CharacterDecision[]>;
+}
+export declare const characterAgentSystem: CharacterAgentSystem;

package/dist/world/characterAgent.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.characterAgentSystem = exports.CharacterAgentSystem = void 0;
+const client_js_1 = require("../llm/client.js");
+const CHARACTER_DECISION_PROMPT = `You are simulating a character in a narrative. Decide what this character would do next based on their personality, goals, and current situation.
+
+## Character
+
+**Name:** {{name}}
+**Personality:** {{personality}}
+**Current Emotional State:** {{emotionalState}}
+**Location:** {{location}}
+
+### Goals
+{{goals}}
+
+### Current Agenda
+{{agenda}}
+
+### Knowledge
+{{knowledge}}
+
+### Relationships
+{{relationships}}
+
+## Current Situation
+
+**Chapter:** {{chapter}}
+**Story Context:** {{storyContext}}
+
+### Other Characters Present
+{{otherCharacters}}
+
+### Recent World Events
+{{worldEvents}}
+
+## Your Task
+
+Decide what {{name}} would do next. Consider:
+1. Their personality and emotional state
+2. Their current goals and agenda
+3. Their relationships with others
+4. Recent events that might affect their decision
+5. What would create interesting dramatic possibilities
+
+Output JSON:
+{
+  "character": "{{name}}",
+  "action": "What they decide to do (be specific and actionable)",
+  "target": "Who or what they act toward (if anyone)",
+  "reasoning": "Why they make this decision based on their character",
+  "consequences": ["Possible outcomes or reactions from this action"]
+}`;
+class CharacterAgentSystem {
+    /**
+     * Create a character agent from structured state
+     */
+    createAgent(characterState, personality) {
+        return {
+            name: characterState.name,
+            goals: [...characterState.goals],
+            currentGoal: characterState.goals[0] || 'unknown',
+            location: characterState.location,
+            knowledge: [...characterState.knowledge],
+            relationships: { ...characterState.relationships },
+            personality: [...personality],
+            emotionalState: characterState.emotionalState,
+            inventory: [],
+            agenda: [],
+        };
+    }
+    /**
+     * Add an agenda item for a character
+     */
+    addAgendaItem(agent, action, priority = 5, deadline) {
+        return {
+            ...agent,
+            agenda: [
+                ...agent.agenda,
+                {
+                    id: `agenda-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`,
+                    action,
+                    priority,
+                    deadline,
+                    completed: false,
+                },
+            ],
+        };
+    }
+    /**
+     * Complete an agenda item
+     */
+    completeAgendaItem(agent, agendaId) {
+        return {
+            ...agent,
+            agenda: agent.agenda.map(item => item.id === agendaId ? { ...item, completed: true } : item),
+        };
+    }
+    /**
+     * Update character knowledge
+     */
+    addKnowledge(agent, fact) {
+        if (agent.knowledge.includes(fact))
+            return agent;
+        return {
+            ...agent,
+            knowledge: [...agent.knowledge, fact],
+        };
+    }
+    /**
+     * Update relationship
+     */
+    updateRelationship(agent, otherCharacter, relationship) {
+        return {
+            ...agent,
+            relationships: {
+                ...agent.relationships,
+                [otherCharacter]: relationship,
+            },
+        };
+    }
+    /**
+     * Move character to new location
+     */
+    moveTo(agent, location) {
+        return {
+            ...agent,
+            location,
+        };
+    }
+    /**
+     * Get character decision using LLM
+     */
+    async getDecision(context) {
+        const { character, otherCharacters, worldEvents, currentChapter, storyContext } = context;
+        const prompt = CHARACTER_DECISION_PROMPT
+            .replace(/{{name}}/g, character.name)
+            .replace('{{personality}}', character.personality.join(', '))
+            .replace('{{emotionalState}}', character.emotionalState)
+            .replace('{{location}}', character.location)
+            .replace('{{goals}}', character.goals.map(g => `- ${g}`).join('\n'))
+            .replace('{{agenda}}', character.agenda.filter(a => !a.completed).map(a => `- ${a.action} (priority: ${a.priority})`).join('\n') || 'No active agenda')
+            .replace('{{knowledge}}', character.knowledge.map(k => `- ${k}`).join('\n') || 'No special knowledge')
+            .replace('{{relationships}}', Object.entries(character.relationships).map(([name, rel]) => `- ${name}: ${rel}`).join('\n') || 'No significant relationships')
+            .replace('{{chapter}}', currentChapter.toString())
+            .replace('{{storyContext}}', storyContext)
+            .replace('{{otherCharacters}}', otherCharacters.map(c => `- ${c.name} (${c.emotionalState}, at ${c.location})`).join('\n') || 'No other characters present')
+            .replace('{{worldEvents}}', worldEvents.map(e => `- ${e}`).join('\n') || 'No recent events');
+        const result = await (0, client_js_1.getLLM)().completeJSON(prompt, {
+            temperature: 0.5,
+            maxTokens: 1000,
+        });
+        return result;
+    }
+    /**
+     * Get simple decision without LLM (for testing/fallback)
+     */
+    getSimpleDecision(context) {
+        const { character, otherCharacters } = context;
+        // Find incomplete agenda items
+        const activeAgenda = character.agenda.filter(a => !a.completed);
+        if (activeAgenda.length > 0) {
+            // Follow highest priority agenda item
+            const topPriority = activeAgenda.sort((a, b) => b.priority - a.priority)[0];
+            return {
+                character: character.name,
+                action: topPriority.action,
+                reasoning: `Following their agenda: ${topPriority.action}`,
+                consequences: ['Progress toward goal'],
+            };
+        }
+        // React to other characters if present
+        if (otherCharacters.length > 0) {
+            const other = otherCharacters[0];
+            const relationship = character.relationships[other.name] || 'neutral';
+            if (relationship.includes('friend') || relationship.includes('ally')) {
+                return {
+                    character: character.name,
+                    action: `Approach ${other.name} to talk`,
+                    target: other.name,
+                    reasoning: `They are ${relationship} and nearby`,
+                    consequences: ['Social interaction', 'Information exchange'],
+                };
+            }
+            if (relationship.includes('enemy') || relationship.includes('hostile')) {
+                return {
+                    character: character.name,
+                    action: `Keep distance from ${other.name}`,
+                    target: other.name,
+                    reasoning: `They are ${relationship}`,
+                    consequences: ['Avoiding conflict', 'Maintaining safety'],
+                };
+            }
+        }
+        // Default: pursue current goal
+        return {
+            character: character.name,
+            action: `Work toward goal: ${character.currentGoal}`,
+            reasoning: 'No immediate distractions, focusing on primary objective',
+            consequences: ['Progress toward goal', 'Possible new opportunities'],
+        };
+    }
+    /**
+     * Simulate multiple characters making decisions
+     */
+    async simulateTurn(agents, worldEvents, currentChapter, storyContext, useLLM = false) {
+        const decisions = [];
+        for (const agent of agents) {
+            const context = {
+                character: agent,
+                otherCharacters: agents.filter(a => a.name !== agent.name),
+                worldEvents,
+                currentChapter,
+                storyContext,
+            };
+            try {
+                const decision = useLLM
+                    ? await this.getDecision(context)
+                    : this.getSimpleDecision(context);
+                decisions.push(decision);
+            }
+            catch (error) {
+                // Fallback to simple decision on error
+                decisions.push(this.getSimpleDecision(context));
+            }
+        }
+        return decisions;
+    }
+}
+exports.CharacterAgentSystem = CharacterAgentSystem;
+exports.characterAgentSystem = new CharacterAgentSystem();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"characterAgent.js","sourceRoot":"","sources":["../../src/world/characterAgent.ts"],"names":[],"mappings":"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","sourcesContent":["import { getLLM } from '../llm/client.js';\r\nimport type { CharacterState } from '../story/structuredState.js';\r\n\r\nexport interface CharacterAgent {\r\n  name: string;\r\n  goals: string[];\r\n  currentGoal: string;\r\n  location: string;\r\n  knowledge: string[];\r\n  relationships: Record<string, string>;\r\n  personality: string[];\r\n  emotionalState: string;\r\n  inventory: string[];\r\n  agenda: AgendaItem[];\r\n}\r\n\r\nexport interface AgendaItem {\r\n  id: string;\r\n  action: string;\r\n  priority: number;\r\n  deadline?: number; // chapter number\r\n  completed: boolean;\r\n}\r\n\r\nexport interface CharacterDecision {\r\n  character: string;\r\n  action: string;\r\n  target?: string;\r\n  reasoning: string;\r\n  consequences: string[];\r\n}\r\n\r\nexport interface CharacterAgentContext {\r\n  character: CharacterAgent;\r\n  otherCharacters: CharacterAgent[];\r\n  worldEvents: string[];\r\n  currentChapter: number;\r\n  storyContext: string;\r\n}\r\n\r\nconst CHARACTER_DECISION_PROMPT = `You are simulating a character in a narrative. Decide what this character would do next based on their personality, goals, and current situation.\r\n\r\n## Character\r\n\r\n**Name:** {{name}}\r\n**Personality:** {{personality}}\r\n**Current Emotional State:** {{emotionalState}}\r\n**Location:** {{location}}\r\n\r\n### Goals\r\n{{goals}}\r\n\r\n### Current Agenda\r\n{{agenda}}\r\n\r\n### Knowledge\r\n{{knowledge}}\r\n\r\n### Relationships\r\n{{relationships}}\r\n\r\n## Current Situation\r\n\r\n**Chapter:** {{chapter}}\r\n**Story Context:** {{storyContext}}\r\n\r\n### Other Characters Present\r\n{{otherCharacters}}\r\n\r\n### Recent World Events\r\n{{worldEvents}}\r\n\r\n## Your Task\r\n\r\nDecide what {{name}} would do next. Consider:\r\n1. Their personality and emotional state\r\n2. Their current goals and agenda\r\n3. Their relationships with others\r\n4. Recent events that might affect their decision\r\n5. What would create interesting dramatic possibilities\r\n\r\nOutput JSON:\r\n{\r\n  \"character\": \"{{name}}\",\r\n  \"action\": \"What they decide to do (be specific and actionable)\",\r\n  \"target\": \"Who or what they act toward (if anyone)\",\r\n  \"reasoning\": \"Why they make this decision based on their character\",\r\n  \"consequences\": [\"Possible outcomes or reactions from this action\"]\r\n}`;\r\n\r\nexport class CharacterAgentSystem {\r\n  /**\r\n   * Create a character agent from structured state\r\n   */\r\n  createAgent(characterState: CharacterState, personality: string[]): CharacterAgent {\r\n    return {\r\n      name: characterState.name,\r\n      goals: [...characterState.goals],\r\n      currentGoal: characterState.goals[0] || 'unknown',\r\n      location: characterState.location,\r\n      knowledge: [...characterState.knowledge],\r\n      relationships: { ...characterState.relationships },\r\n      personality: [...personality],\r\n      emotionalState: characterState.emotionalState,\r\n      inventory: [],\r\n      agenda: [],\r\n    };\r\n  }\r\n  \r\n  /**\r\n   * Add an agenda item for a character\r\n   */\r\n  addAgendaItem(\r\n    agent: CharacterAgent,\r\n    action: string,\r\n    priority: number = 5,\r\n    deadline?: number\r\n  ): CharacterAgent {\r\n    return {\r\n      ...agent,\r\n      agenda: [\r\n        ...agent.agenda,\r\n        {\r\n          id: `agenda-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`,\r\n          action,\r\n          priority,\r\n          deadline,\r\n          completed: false,\r\n        },\r\n      ],\r\n    };\r\n  }\r\n  \r\n  /**\r\n   * Complete an agenda item\r\n   */\r\n  completeAgendaItem(agent: CharacterAgent, agendaId: string): CharacterAgent {\r\n    return {\r\n      ...agent,\r\n      agenda: agent.agenda.map(item =>\r\n        item.id === agendaId ? { ...item, completed: true } : item\r\n      ),\r\n    };\r\n  }\r\n  \r\n  /**\r\n   * Update character knowledge\r\n   */\r\n  addKnowledge(agent: CharacterAgent, fact: string): CharacterAgent {\r\n    if (agent.knowledge.includes(fact)) return agent;\r\n    return {\r\n      ...agent,\r\n      knowledge: [...agent.knowledge, fact],\r\n    };\r\n  }\r\n  \r\n  /**\r\n   * Update relationship\r\n   */\r\n  updateRelationship(\r\n    agent: CharacterAgent,\r\n    otherCharacter: string,\r\n    relationship: string\r\n  ): CharacterAgent {\r\n    return {\r\n      ...agent,\r\n      relationships: {\r\n        ...agent.relationships,\r\n        [otherCharacter]: relationship,\r\n      },\r\n    };\r\n  }\r\n  \r\n  /**\r\n   * Move character to new location\r\n   */\r\n  moveTo(agent: CharacterAgent, location: string): CharacterAgent {\r\n    return {\r\n      ...agent,\r\n      location,\r\n    };\r\n  }\r\n  \r\n  /**\r\n   * Get character decision using LLM\r\n   */\r\n  async getDecision(context: CharacterAgentContext): Promise<CharacterDecision> {\r\n    const { character, otherCharacters, worldEvents, currentChapter, storyContext } = context;\r\n    \r\n    const prompt = CHARACTER_DECISION_PROMPT\r\n      .replace(/{{name}}/g, character.name)\r\n      .replace('{{personality}}', character.personality.join(', '))\r\n      .replace('{{emotionalState}}', character.emotionalState)\r\n      .replace('{{location}}', character.location)\r\n      .replace('{{goals}}', character.goals.map(g => `- ${g}`).join('\\n'))\r\n      .replace('{{agenda}}', character.agenda.filter(a => !a.completed).map(a => `- ${a.action} (priority: ${a.priority})`).join('\\n') || 'No active agenda')\r\n      .replace('{{knowledge}}', character.knowledge.map(k => `- ${k}`).join('\\n') || 'No special knowledge')\r\n      .replace('{{relationships}}', Object.entries(character.relationships).map(([name, rel]) => `- ${name}: ${rel}`).join('\\n') || 'No significant relationships')\r\n      .replace('{{chapter}}', currentChapter.toString())\r\n      .replace('{{storyContext}}', storyContext)\r\n      .replace('{{otherCharacters}}', otherCharacters.map(c => `- ${c.name} (${c.emotionalState}, at ${c.location})`).join('\\n') || 'No other characters present')\r\n      .replace('{{worldEvents}}', worldEvents.map(e => `- ${e}`).join('\\n') || 'No recent events');\r\n    \r\n    const result = await getLLM().completeJSON<CharacterDecision>(prompt, {\r\n      temperature: 0.5,\r\n      maxTokens: 1000,\r\n    });\r\n    \r\n    return result;\r\n  }\r\n  \r\n  /**\r\n   * Get simple decision without LLM (for testing/fallback)\r\n   */\r\n  getSimpleDecision(context: CharacterAgentContext): CharacterDecision {\r\n    const { character, otherCharacters } = context;\r\n    \r\n    // Find incomplete agenda items\r\n    const activeAgenda = character.agenda.filter(a => !a.completed);\r\n    \r\n    if (activeAgenda.length > 0) {\r\n      // Follow highest priority agenda item\r\n      const topPriority = activeAgenda.sort((a, b) => b.priority - a.priority)[0];\r\n      return {\r\n        character: character.name,\r\n        action: topPriority.action,\r\n        reasoning: `Following their agenda: ${topPriority.action}`,\r\n        consequences: ['Progress toward goal'],\r\n      };\r\n    }\r\n    \r\n    // React to other characters if present\r\n    if (otherCharacters.length > 0) {\r\n      const other = otherCharacters[0];\r\n      const relationship = character.relationships[other.name] || 'neutral';\r\n      \r\n      if (relationship.includes('friend') || relationship.includes('ally')) {\r\n        return {\r\n          character: character.name,\r\n          action: `Approach ${other.name} to talk`,\r\n          target: other.name,\r\n          reasoning: `They are ${relationship} and nearby`,\r\n          consequences: ['Social interaction', 'Information exchange'],\r\n        };\r\n      }\r\n      \r\n      if (relationship.includes('enemy') || relationship.includes('hostile')) {\r\n        return {\r\n          character: character.name,\r\n          action: `Keep distance from ${other.name}`,\r\n          target: other.name,\r\n          reasoning: `They are ${relationship}`,\r\n          consequences: ['Avoiding conflict', 'Maintaining safety'],\r\n        };\r\n      }\r\n    }\r\n    \r\n    // Default: pursue current goal\r\n    return {\r\n      character: character.name,\r\n      action: `Work toward goal: ${character.currentGoal}`,\r\n      reasoning: 'No immediate distractions, focusing on primary objective',\r\n      consequences: ['Progress toward goal', 'Possible new opportunities'],\r\n    };\r\n  }\r\n  \r\n  /**\r\n   * Simulate multiple characters making decisions\r\n   */\r\n  async simulateTurn(\r\n    agents: CharacterAgent[],\r\n    worldEvents: string[],\r\n    currentChapter: number,\r\n    storyContext: string,\r\n    useLLM: boolean = false\r\n  ): Promise<CharacterDecision[]> {\r\n    const decisions: CharacterDecision[] = [];\r\n    \r\n    for (const agent of agents) {\r\n      const context: CharacterAgentContext = {\r\n        character: agent,\r\n        otherCharacters: agents.filter(a => a.name !== agent.name),\r\n        worldEvents,\r\n        currentChapter,\r\n        storyContext,\r\n      };\r\n      \r\n      try {\r\n        const decision = useLLM\r\n          ? await this.getDecision(context)\r\n          : this.getSimpleDecision(context);\r\n        decisions.push(decision);\r\n      } catch (error) {\r\n        // Fallback to simple decision on error\r\n        decisions.push(this.getSimpleDecision(context));\r\n      }\r\n    }\r\n    \r\n    return decisions;\r\n  }\r\n}\r\n\r\nexport const characterAgentSystem = new CharacterAgentSystem();\r\n"]}

package/dist/world/eventResolver.d.ts

@@ -0,0 +1,52 @@
+import type { CharacterAgent } from './characterAgent.js';
+import type { CharacterDecision } from './characterAgent.js';
+export interface WorldEvent {
+    id: string;
+    type: 'interaction' | 'conflict' | 'discovery' | 'movement' | 'environmental';
+    description: string;
+    participants: string[];
+    location: string;
+    chapter: number;
+    resolved: boolean;
+    outcome?: string;
+}
+export interface EventResolution {
+    event: WorldEvent;
+    outcome: string;
+    affectedCharacters: string[];
+    consequences: string[];
+    newEvents?: string[];
+}
+export interface ConflictResolution {
+    winner?: string;
+    compromise: boolean;
+    outcome: string;
+    damage: string[];
+}
+export declare class EventResolver {
+    /**
+     * Resolve character decisions into world events
+     */
+    resolveDecisions(decisions: CharacterDecision[], currentChapter: number): WorldEvent[];
+    /**
+     * Categorize an action into event type
+     */
+    private categorizeAction;
+    /**
+     * Resolve a conflict between characters
+     */
+    resolveConflict(event: WorldEvent, participants: CharacterAgent[]): ConflictResolution;
+    /**
+     * Resolve an event and determine consequences
+     */
+    resolveEvent(event: WorldEvent, participants: CharacterAgent[]): EventResolution;
+    /**
+     * Process all pending events
+     */
+    processEvents(events: WorldEvent[], agents: Map<string, CharacterAgent>): EventResolution[];
+    /**
+     * Generate narrative description of event resolution
+     */
+    narrateResolution(resolution: EventResolution): string;
+}
+export declare const eventResolver: EventResolver;

package/dist/world/eventResolver.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventResolver = exports.EventResolver = void 0;
+class EventResolver {
+    /**
+     * Resolve character decisions into world events
+     */
+    resolveDecisions(decisions, currentChapter) {
+        const events = [];
+        // Group decisions by location
+        const locationGroups = new Map();
+        for (const decision of decisions) {
+            // Note: location would need to be passed in or tracked
+            const location = 'current location'; // Simplified
+            const existing = locationGroups.get(location) || [];
+            existing.push(decision);
+            locationGroups.set(location, existing);
+        }
+        // Check for interactions between characters at same location
+        for (const [location, locationDecisions] of locationGroups) {
+            if (locationDecisions.length >= 2) {
+                // Check for mutual interactions
+                for (let i = 0; i < locationDecisions.length; i++) {
+                    for (let j = i + 1; j < locationDecisions.length; j++) {
+                        const d1 = locationDecisions[i];
+                        const d2 = locationDecisions[j];
+                        // Check if they're interacting with each other
+                        if (d1.target === d2.character && d2.target === d1.character) {
+                            events.push({
+                                id: `event-${Date.now()}-${events.length}`,
+                                type: 'interaction',
+                                description: `${d1.character} and ${d2.character} interact`,
+                                participants: [d1.character, d2.character],
+                                location,
+                                chapter: currentChapter,
+                                resolved: false,
+                            });
+                        }
+                    }
+                }
+            }
+            // Add individual actions as events
+            for (const decision of locationDecisions) {
+                if (!events.some(e => e.participants.includes(decision.character))) {
+                    events.push({
+                        id: `event-${Date.now()}-${events.length}`,
+                        type: this.categorizeAction(decision.action),
+                        description: `${decision.character}: ${decision.action}`,
+                        participants: [decision.character],
+                        location,
+                        chapter: currentChapter,
+                        resolved: false,
+                    });
+                }
+            }
+        }
+        return events;
+    }
+    /**
+     * Categorize an action into event type
+     */
+    categorizeAction(action) {
+        const actionLower = action.toLowerCase();
+        if (actionLower.includes('fight') || actionLower.includes('attack') || actionLower.includes('confront')) {
+            return 'conflict';
+        }
+        if (actionLower.includes('find') || actionLower.includes('discover') || actionLower.includes('learn')) {
+            return 'discovery';
+        }
+        if (actionLower.includes('go') || actionLower.includes('move') || actionLower.includes('travel')) {
+            return 'movement';
+        }
+        if (actionLower.includes('weather') || actionLower.includes('storm') || actionLower.includes('dark')) {
+            return 'environmental';
+        }
+        return 'interaction';
+    }
+    /**
+     * Resolve a conflict between characters
+     */
+    resolveConflict(event, participants) {
+        // Simple resolution based on emotional state and personality
+        const scores = participants.map(p => {
+            let score = 5; // base
+            // Emotional state affects capability
+            if (p.emotionalState.includes('angry') || p.emotionalState.includes('furious')) {
+                score += 2;
+            }
+            if (p.emotionalState.includes('fear') || p.emotionalState.includes('terrified')) {
+                score -= 2;
+            }
+            if (p.emotionalState.includes('calm') || p.emotionalState.includes('focused')) {
+                score += 1;
+            }
+            // Personality traits
+            if (p.personality.some(t => t.includes('strong') || t.includes('brave'))) {
+                score += 1;
+            }
+            if (p.personality.some(t => t.includes('weak') || t.includes('timid'))) {
+                score -= 1;
+            }
+            return { name: p.name, score };
+        });
+        // Determine outcome
+        scores.sort((a, b) => b.score - a.score);
+        const winner = scores[0];
+        const loser = scores[scores.length - 1];
+        const scoreDiff = winner.score - loser.score;
+        if (scoreDiff < 2) {
+            // Close match - compromise
+            return {
+                compromise: true,
+                outcome: 'Both sides reach a compromise',
+                damage: ['Minor injuries', 'Tension remains'],
+            };
+        }
+        return {
+            winner: winner.name,
+            compromise: false,
+            outcome: `${winner.name} prevails over ${loser.name}`,
+            damage: [`${loser.name} is defeated`, 'Physical or emotional consequences'],
+        };
+    }
+    /**
+     * Resolve an event and determine consequences
+     */
+    resolveEvent(event, participants) {
+        let outcome = '';
+        const consequences = [];
+        const newEvents = [];
+        switch (event.type) {
+            case 'conflict':
+                const conflictResult = this.resolveConflict(event, participants);
+                outcome = conflictResult.outcome;
+                consequences.push(...conflictResult.damage);
+                if (conflictResult.winner) {
+                    consequences.push(`${conflictResult.winner} gains advantage`);
+                }
+                break;
+            case 'discovery':
+                outcome = `${participants[0]?.name} makes an important discovery`;
+                consequences.push('New knowledge gained', 'Future possibilities opened');
+                break;
+            case 'interaction':
+                if (participants.length >= 2) {
+                    outcome = `${participants.map(p => p.name).join(' and ')} have a meaningful interaction`;
+                    consequences.push('Relationship development', 'Information exchange');
+                }
+                else {
+                    outcome = `${participants[0]?.name} takes action`;
+                    consequences.push('Progress toward goal');
+                }
+                break;
+            case 'movement':
+                outcome = `${participants[0]?.name} changes location`;
+                consequences.push('New environment', 'New opportunities or dangers');
+                break;
+            case 'environmental':
+                outcome = 'Environmental event affects the scene';
+                consequences.push('All participants must react', 'Situation becomes more complex');
+                break;
+        }
+        return {
+            event: { ...event, resolved: true, outcome },
+            outcome,
+            affectedCharacters: participants.map(p => p.name),
+            consequences,
+            newEvents,
+        };
+    }
+    /**
+     * Process all pending events
+     */
+    processEvents(events, agents) {
+        const resolutions = [];
+        for (const event of events.filter(e => !e.resolved)) {
+            const participants = event.participants
+                .map(name => agents.get(name))
+                .filter((agent) => agent !== undefined);
+            if (participants.length > 0) {
+                const resolution = this.resolveEvent(event, participants);
+                resolutions.push(resolution);
+            }
+        }
+        return resolutions;
+    }
+    /**
+     * Generate narrative description of event resolution
+     */
+    narrateResolution(resolution) {
+        const lines = [];
+        lines.push(`**${resolution.event.description}**`);
+        lines.push(`Outcome: ${resolution.outcome}`);
+        if (resolution.consequences.length > 0) {
+            lines.push('Consequences:');
+            for (const consequence of resolution.consequences) {
+                lines.push(`  - ${consequence}`);
+            }
+        }
+        return lines.join('\n');
+    }
+}
+exports.EventResolver = EventResolver;
+exports.eventResolver = new EventResolver();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eventResolver.js","sourceRoot":"","sources":["../../src/world/eventResolver.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CharacterAgent } from './characterAgent.js';\r\nimport type { CharacterDecision } from './characterAgent.js';\r\n\r\nexport interface WorldEvent {\r\n  id: string;\r\n  type: 'interaction' | 'conflict' | 'discovery' | 'movement' | 'environmental';\r\n  description: string;\r\n  participants: string[];\r\n  location: string;\r\n  chapter: number;\r\n  resolved: boolean;\r\n  outcome?: string;\r\n}\r\n\r\nexport interface EventResolution {\r\n  event: WorldEvent;\r\n  outcome: string;\r\n  affectedCharacters: string[];\r\n  consequences: string[];\r\n  newEvents?: string[];\r\n}\r\n\r\nexport interface ConflictResolution {\r\n  winner?: string;\r\n  compromise: boolean;\r\n  outcome: string;\r\n  damage: string[];\r\n}\r\n\r\nexport class EventResolver {\r\n  /**\r\n   * Resolve character decisions into world events\r\n   */\r\n  resolveDecisions(\r\n    decisions: CharacterDecision[],\r\n    currentChapter: number\r\n  ): WorldEvent[] {\r\n    const events: WorldEvent[] = [];\r\n    \r\n    // Group decisions by location\r\n    const locationGroups = new Map<string, CharacterDecision[]>();\r\n    for (const decision of decisions) {\r\n      // Note: location would need to be passed in or tracked\r\n      const location = 'current location'; // Simplified\r\n      const existing = locationGroups.get(location) || [];\r\n      existing.push(decision);\r\n      locationGroups.set(location, existing);\r\n    }\r\n    \r\n    // Check for interactions between characters at same location\r\n    for (const [location, locationDecisions] of locationGroups) {\r\n      if (locationDecisions.length >= 2) {\r\n        // Check for mutual interactions\r\n        for (let i = 0; i < locationDecisions.length; i++) {\r\n          for (let j = i + 1; j < locationDecisions.length; j++) {\r\n            const d1 = locationDecisions[i];\r\n            const d2 = locationDecisions[j];\r\n            \r\n            // Check if they're interacting with each other\r\n            if (d1.target === d2.character && d2.target === d1.character) {\r\n              events.push({\r\n                id: `event-${Date.now()}-${events.length}`,\r\n                type: 'interaction',\r\n                description: `${d1.character} and ${d2.character} interact`,\r\n                participants: [d1.character, d2.character],\r\n                location,\r\n                chapter: currentChapter,\r\n                resolved: false,\r\n              });\r\n            }\r\n          }\r\n        }\r\n      }\r\n      \r\n      // Add individual actions as events\r\n      for (const decision of locationDecisions) {\r\n        if (!events.some(e => e.participants.includes(decision.character))) {\r\n          events.push({\r\n            id: `event-${Date.now()}-${events.length}`,\r\n            type: this.categorizeAction(decision.action),\r\n            description: `${decision.character}: ${decision.action}`,\r\n            participants: [decision.character],\r\n            location,\r\n            chapter: currentChapter,\r\n            resolved: false,\r\n          });\r\n        }\r\n      }\r\n    }\r\n    \r\n    return events;\r\n  }\r\n  \r\n  /**\r\n   * Categorize an action into event type\r\n   */\r\n  private categorizeAction(action: string): WorldEvent['type'] {\r\n    const actionLower = action.toLowerCase();\r\n    \r\n    if (actionLower.includes('fight') || actionLower.includes('attack') || actionLower.includes('confront')) {\r\n      return 'conflict';\r\n    }\r\n    if (actionLower.includes('find') || actionLower.includes('discover') || actionLower.includes('learn')) {\r\n      return 'discovery';\r\n    }\r\n    if (actionLower.includes('go') || actionLower.includes('move') || actionLower.includes('travel')) {\r\n      return 'movement';\r\n    }\r\n    if (actionLower.includes('weather') || actionLower.includes('storm') || actionLower.includes('dark')) {\r\n      return 'environmental';\r\n    }\r\n    \r\n    return 'interaction';\r\n  }\r\n  \r\n  /**\r\n   * Resolve a conflict between characters\r\n   */\r\n  resolveConflict(\r\n    event: WorldEvent,\r\n    participants: CharacterAgent[]\r\n  ): ConflictResolution {\r\n    // Simple resolution based on emotional state and personality\r\n    const scores = participants.map(p => {\r\n      let score = 5; // base\r\n      \r\n      // Emotional state affects capability\r\n      if (p.emotionalState.includes('angry') || p.emotionalState.includes('furious')) {\r\n        score += 2;\r\n      }\r\n      if (p.emotionalState.includes('fear') || p.emotionalState.includes('terrified')) {\r\n        score -= 2;\r\n      }\r\n      if (p.emotionalState.includes('calm') || p.emotionalState.includes('focused')) {\r\n        score += 1;\r\n      }\r\n      \r\n      // Personality traits\r\n      if (p.personality.some(t => t.includes('strong') || t.includes('brave'))) {\r\n        score += 1;\r\n      }\r\n      if (p.personality.some(t => t.includes('weak') || t.includes('timid'))) {\r\n        score -= 1;\r\n      }\r\n      \r\n      return { name: p.name, score };\r\n    });\r\n    \r\n    // Determine outcome\r\n    scores.sort((a, b) => b.score - a.score);\r\n    const winner = scores[0];\r\n    const loser = scores[scores.length - 1];\r\n    const scoreDiff = winner.score - loser.score;\r\n    \r\n    if (scoreDiff < 2) {\r\n      // Close match - compromise\r\n      return {\r\n        compromise: true,\r\n        outcome: 'Both sides reach a compromise',\r\n        damage: ['Minor injuries', 'Tension remains'],\r\n      };\r\n    }\r\n    \r\n    return {\r\n      winner: winner.name,\r\n      compromise: false,\r\n      outcome: `${winner.name} prevails over ${loser.name}`,\r\n      damage: [`${loser.name} is defeated`, 'Physical or emotional consequences'],\r\n    };\r\n  }\r\n  \r\n  /**\r\n   * Resolve an event and determine consequences\r\n   */\r\n  resolveEvent(\r\n    event: WorldEvent,\r\n    participants: CharacterAgent[]\r\n  ): EventResolution {\r\n    let outcome = '';\r\n    const consequences: string[] = [];\r\n    const newEvents: string[] = [];\r\n    \r\n    switch (event.type) {\r\n      case 'conflict':\r\n        const conflictResult = this.resolveConflict(event, participants);\r\n        outcome = conflictResult.outcome;\r\n        consequences.push(...conflictResult.damage);\r\n        if (conflictResult.winner) {\r\n          consequences.push(`${conflictResult.winner} gains advantage`);\r\n        }\r\n        break;\r\n        \r\n      case 'discovery':\r\n        outcome = `${participants[0]?.name} makes an important discovery`;\r\n        consequences.push('New knowledge gained', 'Future possibilities opened');\r\n        break;\r\n        \r\n      case 'interaction':\r\n        if (participants.length >= 2) {\r\n          outcome = `${participants.map(p => p.name).join(' and ')} have a meaningful interaction`;\r\n          consequences.push('Relationship development', 'Information exchange');\r\n        } else {\r\n          outcome = `${participants[0]?.name} takes action`;\r\n          consequences.push('Progress toward goal');\r\n        }\r\n        break;\r\n        \r\n      case 'movement':\r\n        outcome = `${participants[0]?.name} changes location`;\r\n        consequences.push('New environment', 'New opportunities or dangers');\r\n        break;\r\n        \r\n      case 'environmental':\r\n        outcome = 'Environmental event affects the scene';\r\n        consequences.push('All participants must react', 'Situation becomes more complex');\r\n        break;\r\n    }\r\n    \r\n    return {\r\n      event: { ...event, resolved: true, outcome },\r\n      outcome,\r\n      affectedCharacters: participants.map(p => p.name),\r\n      consequences,\r\n      newEvents,\r\n    };\r\n  }\r\n  \r\n  /**\r\n   * Process all pending events\r\n   */\r\n  processEvents(\r\n    events: WorldEvent[],\r\n    agents: Map<string, CharacterAgent>\r\n  ): EventResolution[] {\r\n    const resolutions: EventResolution[] = [];\r\n    \r\n    for (const event of events.filter(e => !e.resolved)) {\r\n      const participants = event.participants\r\n        .map(name => agents.get(name))\r\n        .filter((agent): agent is CharacterAgent => agent !== undefined);\r\n      \r\n      if (participants.length > 0) {\r\n        const resolution = this.resolveEvent(event, participants);\r\n        resolutions.push(resolution);\r\n      }\r\n    }\r\n    \r\n    return resolutions;\r\n  }\r\n  \r\n  /**\r\n   * Generate narrative description of event resolution\r\n   */\r\n  narrateResolution(resolution: EventResolution): string {\r\n    const lines: string[] = [];\r\n    \r\n    lines.push(`**${resolution.event.description}**`);\r\n    lines.push(`Outcome: ${resolution.outcome}`);\r\n    \r\n    if (resolution.consequences.length > 0) {\r\n      lines.push('Consequences:');\r\n      for (const consequence of resolution.consequences) {\r\n        lines.push(`  - ${consequence}`);\r\n      }\r\n    }\r\n    \r\n    return lines.join('\\n');\r\n  }\r\n}\r\n\r\nexport const eventResolver = new EventResolver();\r\n"]}