reflexive 0.1.0

package/one-shot.js

@@ -0,0 +1,1109 @@
+// Path-Based Story Game Builder & Simulator
+// Created by Reflexive
+// Enhanced with AI-Driven Dynamic Storytelling
+
+// AI Story Generator using Reflexive
+class AIStoryGenerator {
+  static async generateDynamicConsequence(choice, currentState, arcWeights) {
+    // Use AI to generate contextual consequences
+    const prompt = `You are a fantasy story narrator. Given the player's choice "${choice.text}" in a story where they have:
+- Current state: ${JSON.stringify(currentState)}
+- Arc weights: ${JSON.stringify(Object.fromEntries(arcWeights))}
+
+Generate a brief (1-2 sentence) consequence or flavor text that describes what happens next. Make it dramatic and fitting to the tone.`;
+
+    try {
+      if (typeof process !== 'undefined' && process.reflexive && process.reflexive.prompt) {
+        const result = await process.reflexive.prompt(prompt);
+        return result || "Your choice sets events in motion.";
+      }
+    } catch (error) {
+      // Fallback if AI not available
+    }
+    return "Your choice sets events in motion.";
+  }
+
+  static async generateDynamicChoice(currentNode, arcWeights, stateContext) {
+    const dominantArc = this.getDominantArc(arcWeights);
+
+    const prompt = `You are creating a choice for an interactive fantasy story. The player is at: "${currentNode.text}"
+Current dominant arc: ${dominantArc}
+Context: ${JSON.stringify(stateContext)}
+
+Generate ONE interesting choice option (just the text, 4-8 words) that fits the current situation and dominant arc. Make it dramatic and engaging.`;
+
+    try {
+      if (typeof process !== 'undefined' && process.reflexive && process.reflexive.prompt) {
+        const result = await process.reflexive.prompt(prompt);
+        return result || "Continue your journey";
+      }
+    } catch (error) {
+      // Fallback
+    }
+    return "Continue your journey";
+  }
+
+  static getDominantArc(arcWeights) {
+    let maxWeight = 0;
+    let dominant = 'neutral';
+
+    for (const [arc, weight] of arcWeights) {
+      if (weight > maxWeight) {
+        maxWeight = weight;
+        dominant = arc;
+      }
+    }
+    return dominant;
+  }
+
+  static async generateRandomEncounter(currentState, arcWeights) {
+    const dominantArc = this.getDominantArc(arcWeights);
+
+    const prompt = `Generate a brief (2-3 sentences) random encounter for a fantasy story.
+The player has alignment: ${currentState.alignment || 'neutral'}
+Dominant story arc: ${dominantArc}
+
+Create an unexpected event that fits the tone. Keep it concise and dramatic.`;
+
+    try {
+      if (typeof process !== 'undefined' && process.reflexive && process.reflexive.prompt) {
+        const result = await process.reflexive.prompt(prompt);
+        return result || "You encounter something unexpected on the road.";
+      }
+    } catch (error) {
+      // Fallback
+    }
+    return "You encounter something unexpected on the road.";
+  }
+}
+
+class StoryGameBuilder {
+  constructor() {
+    this.nodes = new Map();
+    this.arcs = new Map();
+    this.globalState = {};
+    this.enableAI = true; // Toggle for AI-enhanced storytelling
+  }
+
+  // Define a story node (scene/moment in the story)
+  addNode(id, data) {
+    this.nodes.set(id, {
+      id,
+      text: data.text || '',
+      choices: data.choices || [],
+      onEnter: data.onEnter || null,
+      onExit: data.onExit || null,
+      arcTags: data.arcTags || [], // Tags for tracking which arc we're in
+      ...data
+    });
+    return this;
+  }
+
+  // Define a story arc (collection of nodes with shared theme/plot)
+  addArc(id, data) {
+    this.arcs.set(id, {
+      id,
+      name: data.name || id,
+      weight: data.weight || 1.0, // Base weight for this arc
+      prerequisites: data.prerequisites || {}, // State requirements to access
+      ...data
+    });
+    return this;
+  }
+
+  // Add a choice to a node with math-based weighting
+  addChoice(nodeId, choice) {
+    const node = this.nodes.get(nodeId);
+    if (!node) throw new Error(`Node ${nodeId} not found`);
+
+    node.choices.push({
+      text: choice.text,
+      target: choice.target,
+      weight: choice.weight || 1.0, // Base weight
+      weightFormula: choice.weightFormula || null, // Dynamic weight calculation
+      condition: choice.condition || null, // Function to check if available
+      effects: choice.effects || {}, // State changes when chosen
+      arcModifiers: choice.arcModifiers || {} // Affect arc weights
+    });
+    return this;
+  }
+
+  getGame() {
+    return {
+      nodes: Array.from(this.nodes.values()),
+      arcs: Array.from(this.arcs.values()),
+      globalState: this.globalState
+    };
+  }
+}
+
+class StorySimulator {
+  constructor(game, enableAI = false) {
+    this.nodes = new Map(game.nodes.map(n => [n.id, n]));
+    this.arcs = new Map(game.arcs.map(a => [a.id, a]));
+    this.state = { ...game.globalState };
+    this.currentNode = null;
+    this.history = [];
+    this.arcWeights = new Map();
+    this.enableAI = enableAI;
+    this.aiGeneratedContent = []; // Track AI-generated story elements
+
+    // Initialize arc weights
+    this.arcs.forEach((arc, id) => {
+      this.arcWeights.set(id, arc.weight);
+    });
+  }
+
+  // Generate AI-enhanced flavor text for the current situation
+  async getEnhancedNodeText(nodeId) {
+    const node = this.nodes.get(nodeId);
+    if (!this.enableAI || !node) return node.text;
+
+    // Add AI-generated context based on player's journey
+    try {
+      const journeyContext = this.history.slice(-3).map(h => h.nodeId).join(' → ');
+      const prompt = `Add a brief atmospheric detail (1 sentence) to this scene: "${node.text}"
+Recent journey: ${journeyContext}
+Player state: ${JSON.stringify(this.state)}
+
+Just return the additional atmospheric sentence, nothing else.`;
+
+      if (typeof process !== 'undefined' && process.reflexive && process.reflexive.prompt) {
+        const enhancement = await process.reflexive.prompt(prompt);
+        if (enhancement && enhancement.length > 0 && enhancement.length < 200) {
+          this.aiGeneratedContent.push({ type: 'enhancement', text: enhancement, node: nodeId });
+          return `${node.text} ${enhancement}`;
+        }
+      }
+    } catch (error) {
+      // Fall back to original text
+    }
+
+    return node.text;
+  }
+
+  // Start the game at a specific node
+  start(startNodeId) {
+    this.currentNode = startNodeId;
+    this.enterNode(startNodeId);
+    return this.getCurrentState();
+  }
+
+  enterNode(nodeId) {
+    const node = this.nodes.get(nodeId);
+    if (!node) throw new Error(`Node ${nodeId} not found`);
+
+    this.history.push({
+      nodeId,
+      timestamp: Date.now(),
+      state: { ...this.state }
+    });
+
+    // Execute onEnter callback
+    if (node.onEnter) {
+      node.onEnter(this.state, this);
+    }
+
+    // Update arc weights based on node's arc tags
+    node.arcTags.forEach(arcId => {
+      const current = this.arcWeights.get(arcId) || 1.0;
+      this.arcWeights.set(arcId, current * 1.2); // Boost active arcs
+    });
+  }
+
+  // Get available choices with weighted probabilities
+  getAvailableChoices() {
+    const node = this.nodes.get(this.currentNode);
+    if (!node) return [];
+
+    return node.choices
+      .filter(choice => {
+        // Check if choice is available based on condition
+        if (choice.condition) {
+          return choice.condition(this.state, this);
+        }
+        return true;
+      })
+      .map(choice => {
+        // Calculate dynamic weight
+        let weight = choice.weight;
+
+        if (choice.weightFormula) {
+          weight = choice.weightFormula(this.state, this.arcWeights, this);
+        }
+
+        // Apply arc modifiers
+        Object.keys(choice.arcModifiers).forEach(arcId => {
+          const arcWeight = this.arcWeights.get(arcId) || 1.0;
+          weight *= arcWeight * choice.arcModifiers[arcId];
+        });
+
+        return {
+          ...choice,
+          calculatedWeight: weight
+        };
+      });
+  }
+
+  // Make a choice (can be player-driven or AI-simulated)
+  makeChoice(choiceIndex) {
+    const choices = this.getAvailableChoices();
+    if (choiceIndex >= choices.length) {
+      throw new Error('Invalid choice index');
+    }
+
+    const choice = choices[choiceIndex];
+
+    // Execute onExit callback
+    const currentNode = this.nodes.get(this.currentNode);
+    if (currentNode.onExit) {
+      currentNode.onExit(this.state, this);
+    }
+
+    // Apply choice effects to state
+    Object.assign(this.state, choice.effects);
+
+    // Apply arc weight modifiers
+    Object.keys(choice.arcModifiers).forEach(arcId => {
+      const current = this.arcWeights.get(arcId) || 1.0;
+      const modifier = choice.arcModifiers[arcId];
+      this.arcWeights.set(arcId, current * modifier);
+    });
+
+    // Move to next node
+    this.currentNode = choice.target;
+    this.enterNode(choice.target);
+
+    return this.getCurrentState();
+  }
+
+  // AI auto-play: choose based on weighted probability
+  autoChoose() {
+    const choices = this.getAvailableChoices();
+    if (choices.length === 0) return null;
+
+    // Calculate total weight
+    const totalWeight = choices.reduce((sum, c) => sum + c.calculatedWeight, 0);
+
+    // Random weighted selection
+    let random = Math.random() * totalWeight;
+
+    for (let i = 0; i < choices.length; i++) {
+      random -= choices[i].calculatedWeight;
+      if (random <= 0) {
+        return this.makeChoice(i);
+      }
+    }
+
+    // Fallback to first choice
+    return this.makeChoice(0);
+  }
+
+  getCurrentState() {
+    const node = this.nodes.get(this.currentNode);
+    const choices = this.getAvailableChoices();
+
+    return {
+      nodeId: this.currentNode,
+      text: node.text,
+      choices: choices.map((c, i) => ({
+        index: i,
+        text: c.text,
+        weight: c.calculatedWeight
+      })),
+      state: { ...this.state },
+      arcWeights: Object.fromEntries(this.arcWeights),
+      history: this.history.length
+    };
+  }
+
+  // Save game state to JSON
+  saveGame(filename) {
+    const saveData = {
+      currentNode: this.currentNode,
+      state: this.state,
+      arcWeights: Object.fromEntries(this.arcWeights),
+      history: this.history,
+      timestamp: new Date().toISOString()
+    };
+    return saveData;
+  }
+
+  // Load game state from JSON
+  loadGame(saveData) {
+    this.currentNode = saveData.currentNode;
+    this.state = { ...saveData.state };
+    this.arcWeights = new Map(Object.entries(saveData.arcWeights));
+    this.history = [...saveData.history];
+  }
+
+  // Export story playthrough as narrative text
+  exportNarrative() {
+    let narrative = '='.repeat(60) + '\n';
+    narrative += 'STORY PLAYTHROUGH\n';
+    narrative += '='.repeat(60) + '\n\n';
+
+    this.history.forEach((entry, index) => {
+      const node = this.nodes.get(entry.nodeId);
+      narrative += `Chapter ${index + 1}: ${entry.nodeId.toUpperCase()}\n`;
+      narrative += '-'.repeat(60) + '\n';
+      narrative += `${node.text}\n\n`;
+
+      if (Object.keys(entry.state).length > 0) {
+        narrative += `State: ${JSON.stringify(entry.state)}\n\n`;
+      }
+    });
+
+    const finalState = this.getCurrentState();
+    narrative += '='.repeat(60) + '\n';
+    narrative += 'THE END\n';
+    narrative += '='.repeat(60) + '\n';
+    narrative += `${finalState.text}\n\n`;
+    narrative += `Final State: ${JSON.stringify(finalState.state)}\n`;
+    narrative += `Arc Weights: ${JSON.stringify(finalState.arcWeights)}\n`;
+
+    return narrative;
+  }
+
+  // Run simulation for N steps
+  simulate(steps = 10) {
+    const results = [];
+    for (let i = 0; i < steps && this.getAvailableChoices().length > 0; i++) {
+      results.push(this.autoChoose());
+    }
+    return results;
+  }
+}
+
+// ===== DEMO STORY: Fantasy Adventure with Multiple Arcs =====
+
+function createDemoStory() {
+  const builder = new StoryGameBuilder();
+
+  // Define story arcs
+  builder
+    .addArc('hero', { name: 'Heroic Path', weight: 1.0 })
+    .addArc('dark', { name: 'Dark Path', weight: 1.0 })
+    .addArc('diplomatic', { name: 'Diplomatic Path', weight: 1.0 })
+    .addArc('chaos', { name: 'Chaos Path', weight: 0.5 });
+
+  // Build the story nodes
+  builder
+    .addNode('start', {
+      text: 'You stand at the gates of the ancient city. A guard blocks your path.',
+      arcTags: []
+    })
+    .addNode('heroic_entrance', {
+      text: 'You offer to help the guard with a monster problem. He gratefully lets you pass.',
+      arcTags: ['hero'],
+      onEnter: (state) => { state.reputation = (state.reputation || 0) + 10; }
+    })
+    .addNode('sneak_in', {
+      text: 'You slip past the guard in the shadows. No one notices you.',
+      arcTags: ['dark'],
+      onEnter: (state) => { state.stealth = (state.stealth || 0) + 5; }
+    })
+    .addNode('bribe_guard', {
+      text: 'You slip the guard some gold. He smiles and steps aside.',
+      arcTags: ['diplomatic'],
+      onEnter: (state) => { state.gold = (state.gold || 100) - 20; state.connections = (state.connections || 0) + 1; }
+    })
+    .addNode('tavern', {
+      text: 'Inside the city, you enter a busy tavern. A hooded figure watches you from the corner.',
+      arcTags: []
+    })
+    .addNode('hero_quest', {
+      text: 'The figure reveals a quest to save the kingdom from an ancient evil. You accept with honor.',
+      arcTags: ['hero'],
+      onEnter: (state) => { state.questActive = true; state.alignment = 'good'; }
+    })
+    .addNode('dark_alliance', {
+      text: 'The figure offers you power in exchange for... questionable deeds. You accept.',
+      arcTags: ['dark'],
+      onEnter: (state) => { state.power = (state.power || 0) + 15; state.alignment = 'dark'; }
+    })
+    .addNode('chaos_unleashed', {
+      text: 'You decide to burn the tavern down just for fun. Chaos erupts!',
+      arcTags: ['chaos'],
+      onEnter: (state) => { state.chaos = (state.chaos || 0) + 20; state.wanted = true; }
+    })
+    .addNode('final_battle', {
+      text: 'Your choices have led you here. The final confrontation awaits.',
+      arcTags: []
+    })
+    .addNode('hero_ending', {
+      text: 'You defeat the evil and are celebrated as a hero! The kingdom prospers.',
+      arcTags: ['hero']
+    })
+    .addNode('dark_ending', {
+      text: 'You claim dark power and rule with an iron fist. Fear spreads across the land.',
+      arcTags: ['dark']
+    })
+    .addNode('diplomat_ending', {
+      text: 'Through careful negotiation, you broker peace. Everyone wins.',
+      arcTags: ['diplomatic']
+    });
+
+  // Add choices with weights and arc modifiers
+  builder
+    .addChoice('start', {
+      text: 'Offer to help the guard',
+      target: 'heroic_entrance',
+      weight: 1.0,
+      arcModifiers: { hero: 2.0, dark: 0.5 }
+    })
+    .addChoice('start', {
+      text: 'Sneak past in the shadows',
+      target: 'sneak_in',
+      weight: 1.0,
+      arcModifiers: { dark: 2.0, hero: 0.5 }
+    })
+    .addChoice('start', {
+      text: 'Bribe the guard',
+      target: 'bribe_guard',
+      weight: 1.0,
+      arcModifiers: { diplomatic: 2.0 }
+    });
+
+  builder
+    .addChoice('heroic_entrance', {
+      text: 'Head to the tavern',
+      target: 'tavern',
+      weight: 1.0
+    })
+    .addChoice('sneak_in', {
+      text: 'Head to the tavern',
+      target: 'tavern',
+      weight: 1.0
+    })
+    .addChoice('bribe_guard', {
+      text: 'Head to the tavern',
+      target: 'tavern',
+      weight: 1.0
+    });
+
+  builder
+    .addChoice('tavern', {
+      text: 'Accept the heroic quest',
+      target: 'hero_quest',
+      weight: 1.0,
+      arcModifiers: { hero: 2.5, dark: 0.3 },
+      weightFormula: (state, arcWeights) => {
+        return 1.0 * (arcWeights.get('hero') || 1.0);
+      }
+    })
+    .addChoice('tavern', {
+      text: 'Accept the dark offer',
+      target: 'dark_alliance',
+      weight: 1.0,
+      arcModifiers: { dark: 2.5, hero: 0.3 },
+      weightFormula: (state, arcWeights) => {
+        return 1.0 * (arcWeights.get('dark') || 1.0);
+      }
+    })
+    .addChoice('tavern', {
+      text: 'Burn it all down!',
+      target: 'chaos_unleashed',
+      weight: 0.3,
+      arcModifiers: { chaos: 5.0, hero: 0.1, dark: 0.5 },
+      weightFormula: (state, arcWeights) => {
+        return 0.3 * (arcWeights.get('chaos') || 0.5);
+      }
+    });
+
+  builder
+    .addChoice('hero_quest', {
+      text: 'Face the final battle',
+      target: 'final_battle',
+      weight: 1.0
+    })
+    .addChoice('dark_alliance', {
+      text: 'Face the final battle',
+      target: 'final_battle',
+      weight: 1.0
+    })
+    .addChoice('chaos_unleashed', {
+      text: 'Face the final battle',
+      target: 'final_battle',
+      weight: 1.0
+    });
+
+  builder
+    .addChoice('final_battle', {
+      text: 'Fight with honor',
+      target: 'hero_ending',
+      weight: 1.0,
+      condition: (state) => state.alignment !== 'dark',
+      weightFormula: (state, arcWeights) => {
+        return (arcWeights.get('hero') || 1.0) * 2;
+      }
+    })
+    .addChoice('final_battle', {
+      text: 'Use dark power',
+      target: 'dark_ending',
+      weight: 1.0,
+      condition: (state) => state.alignment !== 'good',
+      weightFormula: (state, arcWeights) => {
+        return (arcWeights.get('dark') || 1.0) * 2;
+      }
+    })
+    .addChoice('final_battle', {
+      text: 'Negotiate peace',
+      target: 'diplomat_ending',
+      weight: 1.0,
+      weightFormula: (state, arcWeights) => {
+        return (arcWeights.get('diplomatic') || 1.0) * 1.5;
+      }
+    });
+
+  return builder.getGame();
+}
+
+// ===== INTERACTIVE GAME SYSTEM =====
+
+import readline from 'readline';
+import fs from 'fs';
+import path from 'path';
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+function question(prompt) {
+  return new Promise((resolve) => {
+    rl.question(prompt, resolve);
+  });
+}
+
+let currentSimulator = null;
+const game = createDemoStory();
+let aiEnhancedMode = false; // Toggle for AI-enhanced storytelling
+
+async function showMainMenu() {
+  console.clear();
+  console.log('╔════════════════════════════════════════════╗');
+  console.log('║  Path-Based Story Game Builder & Simulator ║');
+  console.log('╚════════════════════════════════════════════╝\n');
+  console.log(`📚 Story loaded: ${game.nodes.length} nodes, ${game.arcs.length} arcs`);
+  console.log(`${aiEnhancedMode ? '🤖 AI-Enhanced Mode: ON' : '📖 Classic Mode: ON'}\n`);
+  console.log('MAIN MENU:');
+  console.log('  1. 🎮 Play Interactive Story (You choose)');
+  console.log('  2. 🤖 Run AI Simulation (Watch AI play)');
+  console.log('  3. 📊 Run Multiple Simulations (Statistics)');
+  console.log('  4. 🏗️  Show Story Structure');
+  console.log('  5. 💾 Load Saved Game');
+  console.log('  6. 📖 View Story Graph');
+  console.log('  7. 🏆 Achievements');
+  console.log(`  8. ${aiEnhancedMode ? '📖' : '🤖'} Toggle AI Enhancement (${aiEnhancedMode ? 'ON' : 'OFF'})`);
+  console.log('  9. 🚪 Exit');
+  console.log(' 10. 🎨 Build Custom Story (Claude AI Planning)\n');
+
+  const choice = await question('Enter your choice (1-10): ');
+  return choice.trim();
+}
+
+async function playInteractive() {
+  console.clear();
+  console.log('🎮 INTERACTIVE MODE\n');
+  if (aiEnhancedMode) {
+    console.log('🤖 AI-Enhanced Storytelling: Dynamic content and atmosphere enabled!\n');
+  }
+  console.log('You make the choices. Type the number of your choice and press Enter.\n');
+  console.log('='.repeat(60) + '\n');
+
+  currentSimulator = new StorySimulator(game, aiEnhancedMode);
+  currentSimulator.start('start');
+
+  while (currentSimulator.getAvailableChoices().length > 0) {
+    const state = currentSimulator.getCurrentState();
+
+    console.log(`\n📍 ${state.nodeId.toUpperCase()}`);
+    console.log('─'.repeat(60));
+
+    // Use AI-enhanced text if available
+    let displayText = state.text;
+    if (aiEnhancedMode) {
+      displayText = await currentSimulator.getEnhancedNodeText(state.nodeId);
+    }
+    console.log(`\n${displayText}\n`);
+
+    if (state.choices.length === 0) {
+      console.log('🏁 THE END\n');
+      break;
+    }
+
+    console.log('Your choices:');
+    state.choices.forEach((choice, i) => {
+      const weightBar = '█'.repeat(Math.min(Math.floor(choice.weight), 15));
+      console.log(`  [${i + 1}] ${choice.text}`);
+      console.log(`      Probability: ${weightBar} ${choice.weight.toFixed(2)}`);
+    });
+
+    console.log(`\n📊 Current State: ${JSON.stringify(state.state)}`);
+    console.log(`📈 Arc Weights: ${JSON.stringify(state.arcWeights)}\n`);
+
+    const input = await question('Choose (1-' + state.choices.length + '), "save", "export", or "back": ');
+
+    if (input.toLowerCase() === 'back') {
+      return;
+    }
+
+    if (input.toLowerCase() === 'save') {
+      const saveData = currentSimulator.saveGame();
+      const savePath = path.join(process.cwd(), 'savegame.json');
+      fs.writeFileSync(savePath, JSON.stringify(saveData, null, 2));
+      console.log(`\n💾 Game saved to ${savePath}\n`);
+      await question('Press Enter to continue...');
+      continue;
+    }
+
+    if (input.toLowerCase() === 'export') {
+      const narrative = currentSimulator.exportNarrative();
+      const exportPath = path.join(process.cwd(), `story-${Date.now()}.txt`);
+      fs.writeFileSync(exportPath, narrative);
+      console.log(`\n📄 Story exported to ${exportPath}\n`);
+      await question('Press Enter to continue...');
+      continue;
+    }
+
+    const choiceIndex = parseInt(input) - 1;
+    if (choiceIndex >= 0 && choiceIndex < state.choices.length) {
+      currentSimulator.makeChoice(choiceIndex);
+    } else {
+      console.log('❌ Invalid choice. Try again.');
+      await question('Press Enter to continue...');
+    }
+  }
+
+  const finalState = currentSimulator.getCurrentState();
+  console.log('\n' + '='.repeat(60));
+  console.log('🏁 STORY COMPLETE!');
+  console.log('='.repeat(60));
+  console.log(`\n${finalState.text}\n`);
+  console.log(`📊 Final State: ${JSON.stringify(finalState.state)}`);
+  console.log(`📈 Final Arc Weights: ${JSON.stringify(finalState.arcWeights)}`);
+  console.log(`📜 Total Decisions: ${finalState.history}\n`);
+
+  // Check for achievements
+  const newAchievements = checkAchievements(currentSimulator);
+  if (newAchievements.length > 0) {
+    console.log('🏆 NEW ACHIEVEMENTS UNLOCKED!\n');
+    newAchievements.forEach(achievement => {
+      console.log(`✨ ${achievement.name}: ${achievement.desc}`);
+    });
+    console.log('');
+  }
+
+  await question('Press Enter to return to menu...');
+}
+
+async function runAISimulation() {
+  console.clear();
+  console.log('🤖 AI SIMULATION MODE\n');
+  console.log('Watch as the AI makes weighted random choices...\n');
+  console.log('='.repeat(60) + '\n');
+
+  const simulator = new StorySimulator(game);
+  simulator.start('start');
+
+  let step = 0;
+  while (simulator.getAvailableChoices().length > 0 && step < 20) {
+    const state = simulator.getCurrentState();
+
+    console.log(`📍 Step ${step + 1}: ${state.nodeId}`);
+    console.log(`   ${state.text}\n`);
+
+    if (state.choices.length > 0) {
+      console.log('   Available choices:');
+      state.choices.forEach((choice, i) => {
+        const weightBar = '█'.repeat(Math.min(Math.floor(choice.weight * 2), 20));
+        console.log(`   ${i + 1}. ${choice.text} [${weightBar}] (${choice.weight.toFixed(2)})`);
+      });
+
+      console.log('\n   🤖 AI choosing...\n');
+      await new Promise(resolve => setTimeout(resolve, 800)); // Pause for effect
+      simulator.autoChoose();
+    }
+
+    step++;
+  }
+
+  const finalState = simulator.getCurrentState();
+  console.log(`\n🏁 ENDING: ${finalState.nodeId}`);
+  console.log(`   ${finalState.text}\n`);
+  console.log(`📊 Final State: ${JSON.stringify(finalState.state)}`);
+  console.log(`📈 Arc Weights: ${JSON.stringify(finalState.arcWeights)}\n`);
+
+  await question('Press Enter to return to menu...');
+}
+
+async function runMultipleSimulations() {
+  console.clear();
+  const count = await question('How many simulations to run? (1-10): ');
+  const numSims = Math.min(Math.max(parseInt(count) || 3, 1), 10);
+
+  console.log(`\n📊 Running ${numSims} simulations...\n`);
+
+  const endingCounts = {};
+  const arcStats = { hero: [], dark: [], diplomatic: [], chaos: [] };
+
+  for (let run = 1; run <= numSims; run++) {
+    console.log(`🎲 Simulation ${run}/${numSims}...`);
+
+    const simulator = new StorySimulator(game);
+    simulator.start('start');
+
+    let step = 0;
+    while (simulator.getAvailableChoices().length > 0 && step < 20) {
+      simulator.autoChoose();
+      step++;
+    }
+
+    const finalState = simulator.getCurrentState();
+    endingCounts[finalState.nodeId] = (endingCounts[finalState.nodeId] || 0) + 1;
+
+    Object.keys(arcStats).forEach(arc => {
+      arcStats[arc].push(finalState.arcWeights[arc] || 0);
+    });
+  }
+
+  console.log('\n' + '='.repeat(60));
+  console.log('📈 SIMULATION RESULTS');
+  console.log('='.repeat(60) + '\n');
+
+  console.log('Ending Distribution:');
+  Object.keys(endingCounts).forEach(ending => {
+    const percentage = ((endingCounts[ending] / numSims) * 100).toFixed(1);
+    const bar = '█'.repeat(Math.floor((endingCounts[ending] / numSims) * 30));
+    console.log(`  ${ending}: ${bar} ${percentage}% (${endingCounts[ending]}/${numSims})`);
+  });
+
+  console.log('\nAverage Final Arc Weights:');
+  Object.keys(arcStats).forEach(arc => {
+    const avg = arcStats[arc].reduce((a, b) => a + b, 0) / arcStats[arc].length;
+    console.log(`  ${arc}: ${avg.toFixed(2)}`);
+  });
+
+  console.log('');
+  await question('Press Enter to return to menu...');
+}
+
+function showStructure() {
+  console.clear();
+  console.log('🏗️  STORY STRUCTURE\n');
+  console.log('='.repeat(60) + '\n');
+
+  console.log('ARCS:');
+  game.arcs.forEach(arc => {
+    console.log(`  • ${arc.name} (weight: ${arc.weight})`);
+  });
+
+  console.log('\nNODES:');
+  game.nodes.forEach(node => {
+    const tags = node.arcTags.length > 0 ? `[${node.arcTags.join(', ')}]` : '[neutral]';
+    console.log(`  • ${node.id} ${tags}`);
+    console.log(`    "${node.text.substring(0, 50)}..."`);
+    console.log(`    ${node.choices.length} choice(s)\n`);
+  });
+}
+
+async function showStructureAndWait() {
+  showStructure();
+  await question('\nPress Enter to return to menu...');
+}
+
+// Load saved game
+async function loadSavedGame() {
+  console.clear();
+  const savePath = path.join(process.cwd(), 'savegame.json');
+
+  if (!fs.existsSync(savePath)) {
+    console.log('❌ No saved game found!\n');
+    await question('Press Enter to return to menu...');
+    return;
+  }
+
+  try {
+    const saveData = JSON.parse(fs.readFileSync(savePath, 'utf8'));
+    console.log('💾 Loading saved game...\n');
+    console.log(`Saved on: ${saveData.timestamp}`);
+    console.log(`Current node: ${saveData.currentNode}`);
+    console.log(`State: ${JSON.stringify(saveData.state)}\n`);
+
+    const confirm = await question('Load this save? (y/n): ');
+    if (confirm.toLowerCase() === 'y') {
+      currentSimulator = new StorySimulator(game);
+      currentSimulator.loadGame(saveData);
+      console.log('\n✅ Game loaded successfully!\n');
+      await question('Press Enter to continue...');
+      await playInteractive();
+    }
+  } catch (error) {
+    console.log(`❌ Error loading save: ${error.message}\n`);
+    await question('Press Enter to return to menu...');
+  }
+}
+
+// View story graph
+async function viewStoryGraph() {
+  console.clear();
+  console.log('📖 STORY GRAPH VISUALIZATION\n');
+  console.log('='.repeat(60) + '\n');
+
+  // Build adjacency map
+  const connections = new Map();
+  game.nodes.forEach(node => {
+    const targets = node.choices.map(c => c.target);
+    connections.set(node.id, targets);
+  });
+
+  // Display graph
+  game.nodes.forEach(node => {
+    const tags = node.arcTags.length > 0 ? `[${node.arcTags.join(', ')}]` : '[neutral]';
+    console.log(`📍 ${node.id} ${tags}`);
+
+    const targets = connections.get(node.id);
+    if (targets.length > 0) {
+      targets.forEach((target, i) => {
+        const choice = node.choices[i];
+        const isLast = i === targets.length - 1;
+        const prefix = isLast ? '└──' : '├──';
+        console.log(`${prefix}> ${choice.text} → ${target}`);
+      });
+    } else {
+      console.log('    (ending)');
+    }
+    console.log('');
+  });
+
+  // Show path statistics
+  console.log('\n📊 PATH STATISTICS:');
+  const endingNodes = game.nodes.filter(n => n.choices.length === 0);
+  console.log(`  Total nodes: ${game.nodes.length}`);
+  console.log(`  Ending nodes: ${endingNodes.length}`);
+  console.log(`  Possible endings: ${endingNodes.map(n => n.id).join(', ')}`);
+
+  await question('\nPress Enter to return to menu...');
+}
+
+// Achievement system
+const achievements = [
+  { id: 'hero_path', name: 'True Hero', desc: 'Complete the heroic ending', check: (sim) => sim.currentNode === 'hero_ending' },
+  { id: 'dark_path', name: 'Dark Lord', desc: 'Complete the dark ending', check: (sim) => sim.currentNode === 'dark_ending' },
+  { id: 'diplomat', name: 'Peacemaker', desc: 'Complete the diplomatic ending', check: (sim) => sim.currentNode === 'diplomat_ending' },
+  { id: 'high_rep', name: 'Renowned', desc: 'Achieve reputation of 10+', check: (sim) => (sim.state.reputation || 0) >= 10 },
+  { id: 'power_hungry', name: 'Power Seeker', desc: 'Accumulate 15+ power', check: (sim) => (sim.state.power || 0) >= 15 },
+  { id: 'all_paths', name: 'Master Explorer', desc: 'Complete all three endings', unlocked: false }
+];
+
+let unlockedAchievements = new Set();
+
+function checkAchievements(simulator) {
+  const newUnlocks = [];
+
+  achievements.forEach(achievement => {
+    if (!unlockedAchievements.has(achievement.id) && achievement.check && achievement.check(simulator)) {
+      unlockedAchievements.add(achievement.id);
+      newUnlocks.push(achievement);
+    }
+  });
+
+  // Check meta achievement
+  const endings = ['hero_ending', 'dark_ending', 'diplomat_ending'];
+  if (endings.every(e => unlockedAchievements.has(e.replace('_ending', '_path')))) {
+    if (!unlockedAchievements.has('all_paths')) {
+      unlockedAchievements.add('all_paths');
+      newUnlocks.push(achievements.find(a => a.id === 'all_paths'));
+    }
+  }
+
+  return newUnlocks;
+}
+
+async function showAchievements() {
+  console.clear();
+  console.log('🏆 ACHIEVEMENTS\n');
+  console.log('='.repeat(60) + '\n');
+
+  achievements.forEach(achievement => {
+    const unlocked = unlockedAchievements.has(achievement.id);
+    const icon = unlocked ? '✅' : '🔒';
+    console.log(`${icon} ${achievement.name}`);
+    console.log(`   ${achievement.desc}\n`);
+  });
+
+  console.log(`Progress: ${unlockedAchievements.size}/${achievements.length} unlocked\n`);
+  await question('Press Enter to return to menu...');
+}
+
+// AI-Assisted Story Planning using Reflexive Breakpoints
+async function buildCustomStory() {
+  console.clear();
+  console.log('🎨 CUSTOM STORY BUILDER\n');
+  console.log('='.repeat(60) + '\n');
+  console.log('This feature uses Reflexive AI breakpoints to pause execution');
+  console.log('and get help from Claude to plan your custom story!\n');
+
+  console.log('📝 Let\'s gather some information about your story:\n');
+
+  const storyTheme = await question('What is the theme/genre? (fantasy, sci-fi, mystery, etc.): ');
+  const storyTone = await question('What tone? (dark, heroic, comedic, dramatic, etc.): ');
+  const numNodes = await question('How many key story nodes? (5-15 recommended): ');
+  const numArcs = await question('How many story arcs/paths? (2-5 recommended): ');
+
+  console.log('\n🤖 Triggering Reflexive AI Breakpoint...');
+  console.log('Claude will help plan your story structure!\n');
+
+  // Set state for Claude to see
+  if (typeof process !== 'undefined' && process.reflexive && process.reflexive.setState) {
+    process.reflexive.setState({
+      mode: 'story_planning',
+      userInput: {
+        theme: storyTheme,
+        tone: storyTone,
+        targetNodes: parseInt(numNodes) || 10,
+        targetArcs: parseInt(numArcs) || 3
+      },
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  // Trigger breakpoint for Claude to help with planning
+  console.log('⏸️  PAUSED: Waiting for Claude AI to help design the story...\n');
+
+  let planResult = null;
+  if (typeof process !== 'undefined' && process.reflexive && process.reflexive.breakpoint) {
+    planResult = await process.reflexive.breakpoint('story_planning', {
+      task: 'Help design a custom story game',
+      context: {
+        theme: storyTheme,
+        tone: storyTone,
+        targetNodes: parseInt(numNodes) || 10,
+        targetArcs: parseInt(numArcs) || 3
+      },
+      instructions: `Please help plan a ${storyTheme} story with a ${storyTone} tone.
+      Create a structure with ${numNodes} nodes and ${numArcs} arcs.
+      Suggest: node names, arc themes, key choice points, and how they connect.
+      Return a structured plan with arcs, nodes, and choices arrays.`
+    });
+
+    console.log('\n✅ Claude has provided planning assistance!');
+    if (planResult && planResult.plan) {
+      console.log('\n📋 Plan Summary:');
+      console.log(`Theme: ${planResult.plan.theme}`);
+      console.log(`Tone: ${planResult.plan.tone}`);
+      console.log(`Arcs: ${planResult.plan.arcs.length}`);
+      console.log(`Nodes: ${planResult.plan.nodes.length}`);
+      console.log(`Choices: ${planResult.plan.choices.length}`);
+
+      console.log('\n🎯 Story Arcs:');
+      planResult.plan.arcs.forEach(arc => {
+        console.log(`  • ${arc.name}: ${arc.theme}`);
+      });
+
+      // Ask if user wants to generate the code
+      const generate = await question('\n📝 Generate story code file? (y/n): ');
+      if (generate.toLowerCase() === 'y') {
+        console.log('\n🤖 Triggering code generation breakpoint...');
+
+        const codeResult = await process.reflexive.breakpoint('code_generation', {
+          task: 'Generate executable story game code',
+          context: {
+            plan: planResult.plan,
+            theme: storyTheme,
+            tone: storyTone
+          },
+          instructions: `Generate a complete JavaScript file that implements this story using the StoryGameBuilder class.
+          Include all arcs, nodes, and choices from the plan.
+          Make it a standalone file that can be run.
+          Use the same patterns as the demo story in one-shot.js.
+          Return the complete code as a string.`
+        });
+
+        if (codeResult && codeResult.code) {
+          const filename = `story-${storyTheme.toLowerCase().replace(/\s+/g, '-')}-${Date.now()}.js`;
+          const filepath = path.join(process.cwd(), filename);
+
+          fs.writeFileSync(filepath, codeResult.code);
+          console.log(`\n✅ Story generated: ${filename}`);
+          console.log(`📂 Location: ${filepath}`);
+          console.log('\n🎮 You can now run: node ${filename}');
+        }
+      }
+    }
+  } else {
+    console.log('⚠️  Reflexive breakpoint API not available.');
+    console.log('This feature requires running with Reflexive CLI integration.');
+  }
+
+  console.log('\n💡 TIP: The Reflexive CLI agent can see your requirements');
+  console.log('and help generate the story structure code!\n');
+
+  await question('Press Enter to return to menu...');
+}
+
+// ===== MAIN EXECUTION =====
+
+async function main() {
+  console.log('🚀 Starting Story Game Engine...\n');
+
+  let running = true;
+  while (running) {
+    const choice = await showMainMenu();
+
+    switch (choice) {
+      case '1':
+        await playInteractive();
+        if (currentSimulator) {
+          const newAchievements = checkAchievements(currentSimulator);
+          if (newAchievements.length > 0) {
+            console.log('\n🎉 NEW ACHIEVEMENTS UNLOCKED! 🎉\n');
+            newAchievements.forEach(a => console.log(`🏆 ${a.name}: ${a.desc}`));
+            await question('\nPress Enter to continue...');
+          }
+        }
+        break;
+      case '2':
+        await runAISimulation();
+        break;
+      case '3':
+        await runMultipleSimulations();
+        break;
+      case '4':
+        await showStructureAndWait();
+        break;
+      case '5':
+        await loadSavedGame();
+        break;
+      case '6':
+        await viewStoryGraph();
+        break;
+      case '7':
+        await showAchievements();
+        break;
+      case '8':
+        aiEnhancedMode = !aiEnhancedMode;
+        console.log(`\n${aiEnhancedMode ? '🤖 AI-Enhanced Mode ENABLED!' : '📖 Classic Mode ENABLED!'}`);
+        console.log(aiEnhancedMode
+          ? 'The AI will now generate dynamic atmospheric details and enhance your story!\n'
+          : 'Story will use original static content.\n');
+        await question('Press Enter to continue...');
+        break;
+      case '9':
+        console.log('\n👋 Thanks for playing! Goodbye.\n');
+        running = false;
+        break;
+      case '10':
+        await buildCustomStory();
+        break;
+      default:
+        console.log('❌ Invalid choice. Press Enter...');
+        await question('');
+    }
+  }
+
+  rl.close();
+}
+
+main().catch(console.error);