reflexive 0.1.0

package/story-game-reflexive.js

@@ -0,0 +1,1246 @@
+// AI-Driven Story Game with Reflexive
+// Fully dynamic - story theme driven by prompts, not hardcoded
+
+import readline from 'readline';
+import http from 'http';
+import express from 'express';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { makeReflexive } from './src/reflexive.js';
+
+// Web server port configuration
+const WEB_PORT = 3100;
+
+// Story Configuration - CHANGE THIS TO CHANGE THE ENTIRE GAME
+const STORY_CONFIG = {
+  genre: 'comedy adventure',
+  theme: 'a hapless lounge lizard trying to find love and fortune in the big city',
+  tone: 'humorous, playful, cheeky with clever wordplay and puns',
+  craftingGuidelines: [
+    'Use witty observations and self-deprecating humor',
+    'Include double entendres and playful innuendo (keep it PG-13)',
+    'Make situations comedically awkward and embarrassing',
+    'Add unexpected punchlines and comedic timing to descriptions'
+  ],
+  // Dynamic length control - prompts will adjust story pacing based on quality
+  lengthControl: {
+    enabled: true,
+    showDebug: true,   // Display quality metrics during gameplay
+    qualityThresholds: {
+      excellent: 0.8,    // Story is highly engaging, extend it
+      good: 0.5,         // Story is decent, normal length
+      poor: 0.3          // Story is weak, wrap it up
+    },
+    targetLengths: {
+      excellent: '12-15 scenes',
+      good: '6-8 scenes',
+      poor: '3-4 scenes'
+    }
+  }
+};
+
+// Initialize Reflexive with dynamic configuration
+const reflexive = makeReflexive({
+  port: 3098,
+  title: `Reflexive ${STORY_CONFIG.genre.charAt(0).toUpperCase() + STORY_CONFIG.genre.slice(1)} Game`,
+  systemPrompt: `You are a creative storytelling AI for an interactive ${STORY_CONFIG.genre} game.
+
+Theme: ${STORY_CONFIG.theme}
+Tone: ${STORY_CONFIG.tone}
+
+Crafting Guidelines:
+${STORY_CONFIG.craftingGuidelines.map((g, i) => `${i + 1}. ${g}`).join('\n')}
+
+Your role is to:
+1. Generate atmospheric descriptions that enhance the narrative and match the tone
+2. Create dynamic consequences based on player choices that deepen the experience
+3. Suggest creative new choice options that fit the theme and genre
+4. Evolve the story based on player's history and established narrative arcs
+5. Maintain consistency with the emotional tone and thematic elements
+
+Always be concise (1-3 sentences) and match the specified tone perfectly.`
+});
+
+// Story Builder Class
+class StoryGameBuilder {
+  constructor() {
+    this.nodes = new Map();
+    this.arcs = new Map();
+    this.globalState = {};
+    this.metadata = {};
+  }
+
+  setMetadata(data) {
+    this.metadata = { ...this.metadata, ...data };
+    return this;
+  }
+
+  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 || [],
+      ...data
+    });
+    return this;
+  }
+
+  addArc(id, data) {
+    this.arcs.set(id, {
+      id,
+      name: data.name || id,
+      weight: data.weight || 1.0,
+      description: data.description || '',
+      ...data
+    });
+    return this;
+  }
+
+  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,
+      weightFormula: choice.weightFormula || null,
+      condition: choice.condition || null,
+      effects: choice.effects || {},
+      arcModifiers: choice.arcModifiers || {}
+    });
+    return this;
+  }
+
+  getGame() {
+    return {
+      nodes: Array.from(this.nodes.values()),
+      arcs: Array.from(this.arcs.values()),
+      globalState: this.globalState,
+      metadata: this.metadata
+    };
+  }
+}
+
+// Enhanced Simulator with Reflexive AI
+class AIStorySimulator {
+  constructor(game, storyConfig) {
+    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.metadata = game.metadata || {};
+    this.storyConfig = storyConfig;
+    this.currentNode = null;
+    this.history = [];
+    this.arcWeights = new Map();
+    this.storyMemory = [];
+
+    // Quality tracking for dynamic length adjustment
+    this.qualityMetrics = {
+      sceneCount: 0,
+      engagementScore: 0.5, // Start neutral
+      arcProgression: 0,
+      lastEnhancementLength: 0
+    };
+
+    // Initialize arc weights
+    this.arcs.forEach((arc, id) => {
+      this.arcWeights.set(id, arc.weight);
+    });
+
+    reflexive.setState('storyState', this.state);
+    reflexive.setState('currentNode', null);
+    reflexive.setState('storyConfig', this.storyConfig);
+  }
+
+  // Calculate current story quality for dynamic length adjustment
+  calculateStoryQuality() {
+    const dominantArcWeight = Math.max(...Array.from(this.arcWeights.values()));
+    const arcDiversity = this.arcWeights.size > 0 ?
+      new Set(Array.from(this.arcWeights.values()).map(v => Math.floor(v))).size / this.arcWeights.size : 0.5;
+
+    // Quality based on arc progression, engagement, and narrative momentum
+    const quality = (
+      (dominantArcWeight / 10) * 0.4 +  // Arc development (40%)
+      this.qualityMetrics.engagementScore * 0.3 +  // Player engagement (30%)
+      arcDiversity * 0.3  // Story variety (30%)
+    );
+
+    return Math.min(1.0, Math.max(0, quality));
+  }
+
+  // Get pacing guidance based on quality
+  getPacingGuidance() {
+    if (!this.storyConfig.lengthControl?.enabled) {
+      return 'normal pacing';
+    }
+
+    const quality = this.calculateStoryQuality();
+    const thresholds = this.storyConfig.lengthControl.qualityThresholds;
+    const sceneCount = this.qualityMetrics.sceneCount;
+
+    if (quality >= thresholds.excellent) {
+      return `Story is excellent (quality: ${quality.toFixed(2)}). Extend the narrative with rich details and new plot threads. Target: ${this.storyConfig.lengthControl.targetLengths.excellent}. Currently at scene ${sceneCount}.`;
+    } else if (quality >= thresholds.good) {
+      return `Story is good (quality: ${quality.toFixed(2)}). Maintain steady pacing with meaningful progression. Target: ${this.storyConfig.lengthControl.targetLengths.good}. Currently at scene ${sceneCount}.`;
+    } else {
+      return `Story quality is low (${quality.toFixed(2)}). Begin wrapping up toward a satisfying conclusion. Target: ${this.storyConfig.lengthControl.targetLengths.poor}. Currently at scene ${sceneCount}.`;
+    }
+  }
+
+  // Use AI to enhance node text with atmosphere
+  async getEnhancedNodeText(nodeId) {
+    const node = this.nodes.get(nodeId);
+    if (!node) return '';
+
+    this.qualityMetrics.sceneCount++;
+
+    const recentJourney = this.history.slice(-3).map(h => h.nodeId).join(' → ');
+    const dominantArc = this.getDominantArc();
+    const arcDescription = this.arcs.get(dominantArc)?.description || dominantArc;
+    const pacingGuidance = this.getPacingGuidance();
+
+    const prompt = `Scene: "${node.text}"
+Recent journey: ${recentJourney || 'Beginning'}
+Dominant narrative arc: ${arcDescription}
+Player state: ${JSON.stringify(this.state)}
+
+PACING GUIDANCE: ${pacingGuidance}
+
+Add ONE atmospheric sentence that enhances this scene in the style of ${this.storyConfig.genre}. Match the tone: ${this.storyConfig.tone}.
+${pacingGuidance.includes('Extend') ? 'Make it rich and detailed to build narrative depth.' : ''}
+${pacingGuidance.includes('wrapping up') ? 'Keep it concise and hint at resolution approaching.' : ''}
+Return ONLY the enhancement sentence, nothing else.`;
+
+    try {
+      const enhancement = await reflexive.chat(prompt);
+      this.qualityMetrics.lastEnhancementLength = enhancement.length;
+
+      // Update engagement score based on enhancement quality
+      this.qualityMetrics.engagementScore =
+        (this.qualityMetrics.engagementScore * 0.7) +
+        (Math.min(1.0, enhancement.length / 150) * 0.3);
+
+      this.storyMemory.push({ type: 'enhancement', node: nodeId, text: enhancement });
+      return `${node.text}\n\n${enhancement.trim()}`;
+    } catch (error) {
+      console.error('AI enhancement failed:', error.message);
+      return node.text;
+    }
+  }
+
+  // Use AI to generate dynamic choice consequences
+  async getChoiceConsequence(choice, choiceIndex) {
+    const prompt = `The player chose: "${choice.text}"
+Genre: ${this.storyConfig.genre}
+Current state: ${JSON.stringify(this.state)}
+Arc weights: ${JSON.stringify(Object.fromEntries(this.arcWeights))}
+
+Generate a brief (1 sentence) consequence that describes what happens. Match the tone: ${this.storyConfig.tone}.
+Return ONLY the consequence text.`;
+
+    try {
+      const consequence = await reflexive.chat(prompt);
+      return consequence.trim();
+    } catch (error) {
+      return "Your choice sets events in motion.";
+    }
+  }
+
+  // Use AI to suggest an extra dynamic choice
+  async generateBonusChoice(nodeId) {
+    const node = this.nodes.get(nodeId);
+    const dominantArc = this.getDominantArc();
+    const arcDescription = this.arcs.get(dominantArc)?.description || dominantArc;
+    const pacingGuidance = this.getPacingGuidance();
+    const quality = this.calculateStoryQuality();
+
+    // Adjust bonus choice frequency based on quality
+    const shouldGenerateBonus = quality > 0.4; // Only generate if quality is decent
+    if (!shouldGenerateBonus) return null;
+
+    const prompt = `Scene: "${node.text}"
+Genre: ${this.storyConfig.genre}
+Dominant arc: ${arcDescription}
+Recent events: ${this.history.slice(-2).map(h => h.nodeId).join(', ')}
+
+PACING GUIDANCE: ${pacingGuidance}
+
+Suggest ONE creative choice (4-7 words) that fits this moment and matches the ${this.storyConfig.genre} theme.
+${pacingGuidance.includes('Extend') ? 'Suggest a choice that opens new story possibilities.' : ''}
+${pacingGuidance.includes('wrapping up') ? 'Suggest a choice that moves toward resolution.' : ''}
+Return ONLY the choice text, nothing else.`;
+
+    try {
+      const bonusChoice = await reflexive.chat(prompt);
+      return bonusChoice.trim();
+    } catch (error) {
+      return null;
+    }
+  }
+
+  getDominantArc() {
+    let maxWeight = 0;
+    let dominant = 'neutral';
+
+    for (const [arc, weight] of this.arcWeights) {
+      if (weight > maxWeight) {
+        maxWeight = weight;
+        dominant = arc;
+      }
+    }
+    return dominant;
+  }
+
+  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 }
+    });
+
+    if (node.onEnter) {
+      node.onEnter(this.state, this);
+    }
+
+    node.arcTags.forEach(arcId => {
+      const current = this.arcWeights.get(arcId) || 1.0;
+      this.arcWeights.set(arcId, current * 1.2);
+    });
+
+    reflexive.setState('currentNode', nodeId);
+    reflexive.setState('storyState', this.state);
+    reflexive.setState('history', this.history.map(h => h.nodeId));
+  }
+
+  getAvailableChoices() {
+    const node = this.nodes.get(this.currentNode);
+    if (!node) return [];
+
+    return node.choices
+      .filter(choice => {
+        if (choice.condition) {
+          return choice.condition(this.state, this);
+        }
+        return true;
+      })
+      .map(choice => {
+        let weight = choice.weight;
+
+        if (choice.weightFormula) {
+          weight = choice.weightFormula(this.state, this.arcWeights, this);
+        }
+
+        Object.keys(choice.arcModifiers).forEach(arcId => {
+          const arcWeight = this.arcWeights.get(arcId) || 1.0;
+          weight *= arcWeight * choice.arcModifiers[arcId];
+        });
+
+        return {
+          ...choice,
+          calculatedWeight: weight
+        };
+      });
+  }
+
+  async makeChoice(choiceIndex) {
+    const choices = this.getAvailableChoices();
+    if (choiceIndex >= choices.length) {
+      throw new Error('Invalid choice index');
+    }
+
+    const choice = choices[choiceIndex];
+
+    // Get AI-generated consequence
+    const consequence = await this.getChoiceConsequence(choice, choiceIndex);
+    console.log(`\n💫 ${consequence}\n`);
+
+    const currentNode = this.nodes.get(this.currentNode);
+    if (currentNode.onExit) {
+      currentNode.onExit(this.state, this);
+    }
+
+    Object.assign(this.state, choice.effects);
+
+    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);
+    });
+
+    this.currentNode = choice.target;
+    this.enterNode(choice.target);
+
+    return this.getCurrentState();
+  }
+
+  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
+    };
+  }
+}
+
+// Dynamic Story Generator - driven by STORY_CONFIG
+async function generateStoryFromPrompt(config) {
+  const prompt = `Create a ${config.genre} interactive story with the theme: "${config.theme}".
+
+Generate a story structure with:
+1. Three narrative arcs that fit the theme (give each a name and description)
+2. A compelling starting scenario
+3. 2-3 branching paths that lead to different outcomes
+
+Return a JSON object with this structure:
+{
+  "arcs": [{"id": "arc1", "name": "Arc Name", "description": "...", "weight": 1.0}],
+  "startNode": {"id": "start", "text": "Opening scene...", "arcTags": []},
+  "nodes": [{"id": "node1", "text": "...", "arcTags": ["arc1"], "stateEffects": {...}}],
+  "choices": [{"from": "start", "text": "...", "to": "node1", "arcModifiers": {"arc1": 1.5}}]
+}
+
+Keep descriptions vivid and match the tone: ${config.tone}.`;
+
+  try {
+    const response = await reflexive.chat(prompt);
+    // Try to parse JSON from response
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      return JSON.parse(jsonMatch[0]);
+    }
+  } catch (error) {
+    console.log('⚠️  AI story generation not available, using fallback story\n');
+  }
+
+  return null;
+}
+
+// Fallback: Manual story based on config
+function createStoryFromConfig(config) {
+  const builder = new StoryGameBuilder();
+
+  builder.setMetadata({
+    genre: config.genre,
+    theme: config.theme,
+    tone: config.tone
+  });
+
+  if (config.genre === 'comedy adventure') {
+    builder
+      .addArc('smooth', {
+        name: 'Smooth Operator',
+        weight: 1.0,
+        description: 'trying to be cool and suave (with mixed results)'
+      })
+      .addArc('awkward', {
+        name: 'Awkward Moments',
+        weight: 1.0,
+        description: 'stumbling through embarrassing social situations'
+      })
+      .addArc('lucky', {
+        name: 'Dumb Luck',
+        weight: 0.5,
+        description: 'succeeding through sheer coincidence and fortune'
+      });
+
+    builder
+      .addNode('start', {
+        text: 'You stand outside Club Polyester, the hottest disco in town. Your leisure suit is freshly pressed, your cologne is... aggressive. A bouncer with arms like tree trunks blocks the velvet rope.',
+        arcTags: []
+      })
+      .addNode('smooth_talk', {
+        text: 'You flash your "winning" smile and slip the bouncer a twenty. He looks at the bill, then at you, then bursts out laughing. "Kid, this is a Monopoly twenty." But he lets you in anyway out of pity.',
+        arcTags: ['awkward'],
+        onEnter: (state) => { state.confidence = (state.confidence || 50) - 10; state.money = (state.money || 100) - 0; }
+      })
+      .addNode('sneak_in', {
+        text: 'You spot a delivery entrance and slip in behind a crate of disco balls. Unfortunately, you trip and send them rolling across the dance floor. Everyone applauds, thinking it\'s part of the show.',
+        arcTags: ['lucky'],
+        onEnter: (state) => { state.confidence = (state.confidence || 50) + 20; }
+      })
+      .addNode('bar', {
+        text: 'At the bar, you order "something sophisticated" and the bartender hands you a glass of chocolate milk with a tiny umbrella. Next to you sits an attractive stranger reading "The Art of Conversation."',
+        arcTags: []
+      })
+      .addNode('pickup_line', {
+        text: 'You deploy your best pickup line: "Are you a parking ticket? Because you\'ve got FINE written all over you." They groan audibly but can\'t help smiling. "Points for commitment to the bit," they say.',
+        arcTags: ['awkward'],
+        onEnter: (state) => { state.charisma = (state.charisma || 0) + 5; state.reputation = 'endearing_disaster'; }
+      })
+      .addNode('be_genuine', {
+        text: 'You nervously admit you have no idea what you\'re doing and just wanted to meet someone interesting. They laugh warmly. "Finally, some honesty in this place. I\'m Alex. Want to get out of here?"',
+        arcTags: ['smooth'],
+        onEnter: (state) => { state.connection = true; state.confidence = (state.confidence || 50) + 30; }
+      })
+      .addNode('awkward_ending', {
+        text: 'You both leave the club, but in your excitement you walk into a glass door. Alex helps you up, still laughing. "You know what? That was actually kind of adorable." Score!',
+        arcTags: ['awkward']
+      })
+      .addNode('smooth_ending', {
+        text: 'You walk out together under the neon lights. For once, everything went right. Well, mostly right. Okay, you tripped once. But Alex caught you, and that counts for something.',
+        arcTags: ['smooth']
+      })
+      .addNode('lucky_ending', {
+        text: 'As you leave together, a street photographer mistakes you two for models and takes your picture. It ends up on the cover of "Awkward Romance Monthly." You frame it.',
+        arcTags: ['lucky']
+      });
+
+    builder
+      .addChoice('start', {
+        text: 'Try to smooth talk the bouncer',
+        target: 'smooth_talk',
+        arcModifiers: { awkward: 1.8 }
+      })
+      .addChoice('start', {
+        text: 'Find another way in',
+        target: 'sneak_in',
+        arcModifiers: { lucky: 2.0 }
+      });
+
+    builder
+      .addChoice('smooth_talk', {
+        text: 'Head to the bar',
+        target: 'bar'
+      })
+      .addChoice('sneak_in', {
+        text: 'Head to the bar',
+        target: 'bar'
+      });
+
+    builder
+      .addChoice('bar', {
+        text: 'Use your best pickup line',
+        target: 'pickup_line',
+        arcModifiers: { awkward: 2.5 },
+        weightFormula: (state, arcWeights) => (arcWeights.get('awkward') || 1.0)
+      })
+      .addChoice('bar', {
+        text: 'Just be yourself',
+        target: 'be_genuine',
+        arcModifiers: { smooth: 2.5 },
+        weightFormula: (state, arcWeights) => (arcWeights.get('smooth') || 1.0)
+      });
+
+    builder
+      .addChoice('pickup_line', {
+        text: 'Suggest getting some fresh air',
+        target: 'awkward_ending',
+        arcModifiers: { awkward: 2.0 }
+      })
+      .addChoice('pickup_line', {
+        text: 'Ask them to teach you to be cool',
+        target: 'lucky_ending',
+        arcModifiers: { lucky: 3.0 }
+      })
+      .addChoice('be_genuine', {
+        text: 'Leave together',
+        target: 'smooth_ending',
+        arcModifiers: { smooth: 2.0 }
+      });
+  } else if (config.genre === 'horror') {
+    builder
+      .addArc('survival', {
+        name: 'Survival Path',
+        weight: 1.0,
+        description: 'fighting to stay alive and escape'
+      })
+      .addArc('madness', {
+        name: 'Madness Path',
+        weight: 1.0,
+        description: 'descending into psychological horror and insanity'
+      })
+      .addArc('cursed', {
+        name: 'Cursed Path',
+        weight: 0.5,
+        description: 'becoming entangled with dark supernatural forces'
+      });
+
+    builder
+      .addNode('start', {
+        text: 'You awaken in a decrepit mansion. The air reeks of decay. Through the window, you see only darkness—no moon, no stars. A door creaks open down the hall.',
+        arcTags: []
+      })
+      .addNode('investigate_sound', {
+        text: 'You follow the sound down the hallway. The floorboards groan beneath your feet. You find a room with strange symbols drawn in blood on the walls.',
+        arcTags: ['survival'],
+        onEnter: (state) => { state.sanity = (state.sanity || 100) - 10; }
+      })
+      .addNode('hide_in_room', {
+        text: 'You lock yourself in the nearest room. Something scratches at the door from outside. The scratching grows more frantic.',
+        arcTags: ['survival'],
+        onEnter: (state) => { state.fear = (state.fear || 0) + 15; }
+      })
+      .addNode('basement', {
+        text: 'You descend into the basement. The smell is overwhelming. In the dim light, you see a shrine made of bones. A journal lies open beside it.',
+        arcTags: ['cursed']
+      })
+      .addNode('read_journal', {
+        text: 'The journal speaks of an ancient ritual. The previous owner tried to summon something. The last entry reads: "It worked. God help me, it worked."',
+        arcTags: ['madness'],
+        onEnter: (state) => { state.knowledge = 'ritual'; state.sanity = (state.sanity || 100) - 20; }
+      })
+      .addNode('destroy_shrine', {
+        text: 'You smash the bone shrine. A deafening screech echoes through the house. Everything goes silent. Too silent.',
+        arcTags: ['survival'],
+        onEnter: (state) => { state.angry_entity = true; }
+      })
+      .addNode('trapped_ending', {
+        text: 'The doors and windows seal themselves. The walls begin to bleed. You realize with horror: you are not trapped in here with it. It is trapped in here with you. But you cannot leave.',
+        arcTags: ['cursed']
+      })
+      .addNode('escape_ending', {
+        text: 'You break through a window and run. Behind you, the mansion collapses into the earth. But in your pocket, you find a bone from the shrine. It pulses with warmth.',
+        arcTags: ['survival']
+      })
+      .addNode('ritual_ending', {
+        text: 'You complete the ritual from the journal. The entity appears before you, ancient and terrible. You become its vessel. Your consciousness fades as something else takes control.',
+        arcTags: ['madness']
+      });
+
+    builder
+      .addChoice('start', {
+        text: 'Investigate the creaking door',
+        target: 'investigate_sound',
+        arcModifiers: { survival: 1.8 }
+      })
+      .addChoice('start', {
+        text: 'Hide and barricade yourself',
+        target: 'hide_in_room',
+        arcModifiers: { survival: 2.0 }
+      });
+
+    builder
+      .addChoice('investigate_sound', {
+        text: 'Search for a way out',
+        target: 'basement',
+        arcModifiers: { cursed: 1.5 }
+      })
+      .addChoice('hide_in_room', {
+        text: 'The scratching stops. Venture out',
+        target: 'basement'
+      });
+
+    builder
+      .addChoice('basement', {
+        text: 'Read the journal carefully',
+        target: 'read_journal',
+        arcModifiers: { madness: 2.5 },
+        weightFormula: (state, arcWeights) => (arcWeights.get('madness') || 1.0)
+      })
+      .addChoice('basement', {
+        text: 'Destroy the shrine',
+        target: 'destroy_shrine',
+        arcModifiers: { survival: 2.0 },
+        weightFormula: (state, arcWeights) => (arcWeights.get('survival') || 1.0)
+      });
+
+    builder
+      .addChoice('read_journal', {
+        text: 'Attempt to complete the ritual',
+        target: 'ritual_ending',
+        arcModifiers: { madness: 3.0 }
+      })
+      .addChoice('read_journal', {
+        text: 'Flee the house immediately',
+        target: 'escape_ending',
+        arcModifiers: { survival: 2.0 }
+      })
+      .addChoice('destroy_shrine', {
+        text: 'Run while you still can',
+        target: 'escape_ending'
+      })
+      .addChoice('destroy_shrine', {
+        text: 'Stand your ground',
+        target: 'trapped_ending',
+        arcModifiers: { cursed: 2.0 }
+      });
+  }
+
+  return builder.getGame();
+}
+
+// Web Server Setup
+const app = express();
+const activeSessions = new Map();
+
+app.use(express.json());
+
+// Serve the game interface
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+app.get('/', (req, res) => {
+  const html = readFileSync(join(__dirname, 'dashboard.html'), 'utf8');
+  res.send(html);
+});
+
+app.get('/old', (req, res) => {
+  let html = readFileSync(join(__dirname, 'new-ui-template.html'), 'utf8');
+  html = html.replace('THEME_PLACEHOLDER', STORY_CONFIG.theme);
+  res.send(html);
+});
+
+// API endpoint to start a new game session
+app.post('/api/start', async (req, res) => {
+  const sessionId = Date.now().toString();
+  const game = createStoryFromConfig(STORY_CONFIG);
+  const simulator = new AIStorySimulator(game, STORY_CONFIG);
+  simulator.start('start');
+
+  activeSessions.set(sessionId, simulator);
+
+  const state = simulator.getCurrentState();
+  const enhancedText = await simulator.getEnhancedNodeText(state.nodeId);
+  const quality = simulator.calculateStoryQuality();
+
+  res.json({
+    sessionId,
+    state: {
+      text: enhancedText,
+      choices: state.choices,
+      quality: quality,
+      sceneCount: simulator.qualityMetrics.sceneCount,
+      engagement: simulator.qualityMetrics.engagementScore
+    }
+  });
+});
+
+// API endpoint to make a choice
+app.post('/api/choice', async (req, res) => {
+  const { sessionId, choiceIndex } = req.body;
+  const simulator = activeSessions.get(sessionId);
+
+  if (!simulator) {
+    return res.status(404).json({ error: 'Session not found' });
+  }
+
+  await simulator.makeChoice(choiceIndex);
+  const state = simulator.getCurrentState();
+  const enhancedText = await simulator.getEnhancedNodeText(state.nodeId);
+  const quality = simulator.calculateStoryQuality();
+
+  res.json({
+    state: {
+      text: enhancedText,
+      choices: state.choices,
+      quality: quality,
+      sceneCount: simulator.qualityMetrics.sceneCount,
+      engagement: simulator.qualityMetrics.engagementScore
+    }
+  });
+});
+
+// API endpoint to handle custom prompts
+app.post('/api/prompt', async (req, res) => {
+  const { sessionId, prompt } = req.body;
+  const simulator = activeSessions.get(sessionId);
+
+  if (!simulator) {
+    return res.status(404).json({ error: 'Session not found' });
+  }
+
+  const state = simulator.getCurrentState();
+  const node = simulator.nodes.get(state.nodeId);
+
+  // Use AI to generate the next scene based on the custom prompt
+  const dominantArc = simulator.getDominantArc();
+  const arcDescription = simulator.arcs.get(dominantArc)?.description || dominantArc;
+  const pacingGuidance = simulator.getPacingGuidance();
+
+  const aiPrompt = `Current scene: "${node.text}"
+
+Genre: ${simulator.storyConfig.genre}
+Tone: ${simulator.storyConfig.tone}
+Dominant story arc: ${arcDescription}
+Player action: "${prompt}"
+
+PACING GUIDANCE: ${pacingGuidance}
+
+Generate the NEXT scene that follows from the player's action. Write 2-4 sentences describing what happens next.
+Stay true to the ${simulator.storyConfig.genre} genre and maintain the tone.
+${simulator.storyConfig.craftingGuidelines.map(g => '- ' + g).join('\\n')}
+
+Return ONLY the scene text, nothing else.`;
+
+  try {
+    const nextSceneText = await reflexive.chat(aiPrompt);
+
+    // Update quality metrics
+    simulator.qualityMetrics.sceneCount++;
+    simulator.qualityMetrics.lastEnhancementLength = nextSceneText.length;
+
+    // Generate new choices based on the scene
+    const choicesPrompt = `Scene: "${nextSceneText}"
+
+Genre: ${simulator.storyConfig.genre}
+Dominant arc: ${arcDescription}
+
+Generate 2-3 choice options (each 4-7 words) that fit this moment and the ${simulator.storyConfig.genre} theme.
+${pacingGuidance.includes('wrapping up') ? 'Include options that move toward resolution.' : ''}
+
+Return as a JSON array of strings: ["choice 1", "choice 2", "choice 3"]`;
+
+    const choicesResponse = await reflexive.chat(choicesPrompt);
+    let newChoices = [];
+    try {
+      newChoices = JSON.parse(choicesResponse.trim());
+    } catch (e) {
+      // Fallback choices
+      newChoices = ["Continue forward", "Look around", "Take a different approach"];
+    }
+
+    const quality = simulator.calculateStoryQuality();
+
+    res.json({
+      state: {
+        text: nextSceneText,
+        choices: newChoices.map((text, index) => ({
+          index,
+          text,
+          weight: 1.0
+        })),
+        quality: quality,
+        sceneCount: simulator.qualityMetrics.sceneCount,
+        engagement: simulator.qualityMetrics.engagementScore
+      }
+    });
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to generate response: ' + error.message });
+  }
+});
+
+// Start web server
+app.listen(WEB_PORT, () => {
+  console.log(`🌐 Web interface: http://localhost:${WEB_PORT}`);
+});
+
+// Main Game Loop
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+function question(prompt) {
+  return new Promise((resolve) => {
+    rl.question(prompt, resolve);
+  });
+}
+
+async function playGame() {
+  console.clear();
+  const emoji = STORY_CONFIG.genre === 'horror' ? '🕯️' : STORY_CONFIG.genre === 'comedy adventure' ? '😎' : '🎮';
+  console.log(`${emoji}  REFLEXIVE ${STORY_CONFIG.genre.toUpperCase()} GAME ${emoji}\n`);
+  console.log(`Theme: ${STORY_CONFIG.theme}\n`);
+  console.log('='.repeat(60) + '\n');
+
+  const game = createStoryFromConfig(STORY_CONFIG);
+  const simulator = new AIStorySimulator(game, STORY_CONFIG);
+  simulator.start('start');
+
+  while (simulator.getAvailableChoices().length > 0) {
+    const state = simulator.getCurrentState();
+
+    console.log(`\n📍 ${state.nodeId.toUpperCase()}`);
+    console.log('─'.repeat(60));
+
+    // Get AI-enhanced text
+    const enhancedText = await simulator.getEnhancedNodeText(state.nodeId);
+    console.log(`\n${enhancedText}\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(`      ${weightBar} ${choice.weight.toFixed(2)}`);
+    });
+
+    // Optionally generate bonus AI choice
+    if (Math.random() > 0.7) {
+      const bonusChoice = await simulator.generateBonusChoice(state.nodeId);
+      if (bonusChoice) {
+        console.log(`  [✨] ${bonusChoice} (AI-generated)`);
+      }
+    }
+
+    console.log(`\n📊 State: ${JSON.stringify(state.state)}`);
+    console.log(`📈 Arcs: ${JSON.stringify(state.arcWeights)}`);
+
+    // Optional: Show quality metrics (debug mode)
+    if (STORY_CONFIG.lengthControl?.showDebug) {
+      const quality = simulator.calculateStoryQuality();
+      console.log(`🎯 Quality: ${(quality * 100).toFixed(1)}% | Scene: ${simulator.qualityMetrics.sceneCount} | Engagement: ${(simulator.qualityMetrics.engagementScore * 100).toFixed(1)}%`);
+    }
+    console.log();
+
+    const input = await question(`Choose (1-${state.choices.length}): `);
+    const choiceIndex = parseInt(input) - 1;
+
+    if (choiceIndex >= 0 && choiceIndex < state.choices.length) {
+      await simulator.makeChoice(choiceIndex);
+    } else {
+      console.log('❌ Invalid choice. Try again.');
+    }
+  }
+
+  const finalState = simulator.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 Arcs: ${JSON.stringify(finalState.arcWeights)}\n`);
+
+  rl.close();
+}
+
+// Startup - Run both CLI and web server simultaneously
+const emoji = STORY_CONFIG.genre === 'horror' ? '🕯️' : STORY_CONFIG.genre === 'comedy adventure' ? '😎' : '🚀';
+console.log(`${emoji} Starting Reflexive ${STORY_CONFIG.genre.charAt(0).toUpperCase() + STORY_CONFIG.genre.slice(1)} Game...\n`);
+console.log('💡 Dashboard: http://localhost:3098/reflexive\n');
+console.log(`📝 Current Configuration:`);
+console.log(`   Genre: ${STORY_CONFIG.genre}`);
+console.log(`   Theme: ${STORY_CONFIG.theme}`);
+console.log(`   Tone: ${STORY_CONFIG.tone}`);
+if (STORY_CONFIG.lengthControl?.enabled) {
+  console.log(`\n⚡ Dynamic Length Control: ENABLED`);
+  console.log(`   The AI will subtly adjust story length based on quality:`);
+  console.log(`   • Excellent stories → Extended narrative (${STORY_CONFIG.lengthControl.targetLengths.excellent})`);
+  console.log(`   • Good stories → Normal pacing (${STORY_CONFIG.lengthControl.targetLengths.good})`);
+  console.log(`   • Weak stories → Graceful wrap-up (${STORY_CONFIG.lengthControl.targetLengths.poor})`);
+}
+console.log();
+
+playGame().catch(console.error);
+
+// Old server mode code removed - everything below this can be deleted
+if (false) {
+  // Server Mode - Run as web server
+  const sessions = new Map();
+
+  function generateSessionId() {
+    return Math.random().toString(36).substring(2, 15);
+  }
+
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+
+    // CORS headers
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+    if (req.method === 'OPTIONS') {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+
+    // Serve HTML interface
+    if (url.pathname === '/' && req.method === 'GET') {
+      res.writeHead(200, { 'Content-Type': 'text/html' });
+      res.end(`
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${STORY_CONFIG.genre.charAt(0).toUpperCase() + STORY_CONFIG.genre.slice(1)} Story Game</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      min-height: 100vh;
+      padding: 20px;
+      color: #333;
+    }
+    .container {
+      max-width: 900px;
+      margin: 0 auto;
+      background: white;
+      border-radius: 20px;
+      box-shadow: 0 20px 60px rgba(0,0,0,0.3);
+      overflow: hidden;
+    }
+    .header {
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      color: white;
+      padding: 30px;
+      text-align: center;
+    }
+    .header h1 { font-size: 2.5em; margin-bottom: 10px; }
+    .header .config { font-size: 0.9em; opacity: 0.9; margin-top: 10px; }
+    .content {
+      padding: 30px;
+    }
+    .story-text {
+      background: #f8f9fa;
+      padding: 25px;
+      border-radius: 15px;
+      margin-bottom: 25px;
+      line-height: 1.8;
+      font-size: 1.1em;
+      white-space: pre-wrap;
+      border-left: 5px solid #667eea;
+    }
+    .choices {
+      display: flex;
+      flex-direction: column;
+      gap: 15px;
+    }
+    .choice-btn {
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      color: white;
+      border: none;
+      padding: 20px;
+      border-radius: 12px;
+      font-size: 1.1em;
+      cursor: pointer;
+      transition: all 0.3s ease;
+      text-align: left;
+      box-shadow: 0 4px 15px rgba(102, 126, 234, 0.4);
+    }
+    .choice-btn:hover {
+      transform: translateY(-2px);
+      box-shadow: 0 6px 20px rgba(102, 126, 234, 0.6);
+    }
+    .choice-btn:active { transform: translateY(0); }
+    .start-btn {
+      background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+      color: white;
+      border: none;
+      padding: 20px 40px;
+      border-radius: 12px;
+      font-size: 1.3em;
+      cursor: pointer;
+      transition: all 0.3s ease;
+      box-shadow: 0 4px 15px rgba(245, 87, 108, 0.4);
+    }
+    .start-btn:hover {
+      transform: scale(1.05);
+      box-shadow: 0 6px 20px rgba(245, 87, 108, 0.6);
+    }
+    .quality-metrics {
+      background: #e3f2fd;
+      padding: 15px;
+      border-radius: 10px;
+      margin-bottom: 20px;
+      font-size: 0.9em;
+      border-left: 4px solid #2196f3;
+    }
+    .quality-metrics strong { color: #1976d2; }
+    .loading {
+      text-align: center;
+      padding: 40px;
+      font-size: 1.2em;
+      color: #667eea;
+    }
+    .game-complete {
+      background: linear-gradient(135deg, #11998e 0%, #38ef7d 100%);
+      color: white;
+      padding: 30px;
+      border-radius: 15px;
+      text-align: center;
+      font-size: 1.3em;
+      margin-top: 20px;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="header">
+      <h1>🎭 ${STORY_CONFIG.genre.charAt(0).toUpperCase() + STORY_CONFIG.genre.slice(1)} Story Game</h1>
+      <div class="config">
+        <div><strong>Theme:</strong> ${STORY_CONFIG.theme}</div>
+        <div><strong>Tone:</strong> ${STORY_CONFIG.tone}</div>
+        ${STORY_CONFIG.lengthControl?.enabled ? '<div>⚡ Dynamic Length Control: ENABLED</div>' : ''}
+      </div>
+    </div>
+    <div class="content" id="game-content">
+      <div style="text-align: center; padding: 40px;">
+        <button class="start-btn" onclick="startGame()">🚀 Start Adventure</button>
+      </div>
+    </div>
+  </div>
+
+  <script>
+    let sessionId = null;
+
+    async function startGame() {
+      document.getElementById('game-content').innerHTML = '<div class="loading">🎲 Creating your story...</div>';
+
+      const response = await fetch('/api/start', { method: 'POST' });
+      const data = await response.json();
+      sessionId = data.sessionId;
+
+      displayGameState(data.state);
+    }
+
+    async function makeChoice(index) {
+      document.getElementById('game-content').innerHTML = '<div class="loading">📖 Writing next chapter...</div>';
+
+      const response = await fetch('/api/choice', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ sessionId, choiceIndex: index })
+      });
+      const data = await response.json();
+
+      displayGameState(data.state);
+    }
+
+    function displayGameState(state) {
+      let html = '';
+
+      if (state.qualityInfo && ${STORY_CONFIG.lengthControl?.showDebug}) {
+        html += \`<div class="quality-metrics">
+          <strong>📊 Story Quality:</strong> \${(state.qualityInfo.quality * 100).toFixed(1)}% |
+          <strong>Rating:</strong> \${state.qualityInfo.rating} |
+          <strong>Scene:</strong> \${state.qualityInfo.sceneNumber}
+        </div>\`;
+      }
+
+      html += \`<div class="story-text">\${state.text}</div>\`;
+
+      if (state.gameOver) {
+        html += \`<div class="game-complete">
+          🏁 STORY COMPLETE!<br><br>
+          <button class="start-btn" onclick="startGame()">🔄 Play Again</button>
+        </div>\`;
+      } else {
+        html += '<div class="choices">';
+        state.choices.forEach((choice, index) => {
+          html += \`<button class="choice-btn" onclick="makeChoice(\${index})">\${choice}</button>\`;
+        });
+        html += '</div>';
+      }
+
+      document.getElementById('game-content').innerHTML = html;
+    }
+  </script>
+</body>
+</html>
+      `);
+      return;
+    }
+
+    // API: Start new game
+    if (url.pathname === '/api/start' && req.method === 'POST') {
+      const sessionId = generateSessionId();
+      const game = reflexive.createChat('story-game');
+      const simulator = new AIStorySimulator(game, STORY_CONFIG);
+
+      await simulator.initializeStory();
+      sessions.set(sessionId, simulator);
+
+      const state = simulator.getCurrentState();
+      const qualityInfo = STORY_CONFIG.lengthControl?.enabled ? {
+        quality: simulator.calculateStoryQuality(),
+        sceneNumber: simulator.sceneNumber,
+        rating: simulator.getQualityRating()
+      } : null;
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        sessionId,
+        state: { ...state, qualityInfo }
+      }));
+      return;
+    }
+
+    // API: Make choice
+    if (url.pathname === '/api/choice' && req.method === 'POST') {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', async () => {
+        const { sessionId, choiceIndex } = JSON.parse(body);
+        const simulator = sessions.get(sessionId);
+
+        if (!simulator) {
+          res.writeHead(404, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Session not found' }));
+          return;
+        }
+
+        await simulator.makeChoice(choiceIndex);
+        const state = simulator.getCurrentState();
+        const qualityInfo = STORY_CONFIG.lengthControl?.enabled ? {
+          quality: simulator.calculateStoryQuality(),
+          sceneNumber: simulator.sceneNumber,
+          rating: simulator.getQualityRating()
+        } : null;
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          state: { ...state, qualityInfo }
+        }));
+      });
+      return;
+    }
+
+    // 404
+    res.writeHead(404, { 'Content-Type': 'text/plain' });
+    res.end('Not Found');
+  });
+
+  server.listen(WEB_PORT, () => {
+    console.log(`🌐 Server running at http://localhost:${WEB_PORT}`);
+    console.log(`💡 Reflexive Dashboard: http://localhost:3098/reflexive`);
+    console.log(`\n📝 Configuration:`);
+    console.log(`   Genre: ${STORY_CONFIG.genre}`);
+    console.log(`   Theme: ${STORY_CONFIG.theme}`);
+    if (STORY_CONFIG.lengthControl?.enabled) {
+      console.log(`\n⚡ Dynamic Length Control: ENABLED`);
+    }
+    console.log(`\n🎮 Open http://localhost:${WEB_PORT} in your browser to play!\n`);
+  });
+
+} else {
+  // CLI Mode - Original interactive gameplay
+  const emoji = STORY_CONFIG.genre === 'horror' ? '🕯️' : STORY_CONFIG.genre === 'comedy adventure' ? '😎' : '🚀';
+  console.log(`${emoji} Starting Reflexive ${STORY_CONFIG.genre.charAt(0).toUpperCase() + STORY_CONFIG.genre.slice(1)} Game...\n`);
+  console.log('💡 Dashboard: http://localhost:3098/reflexive\n');
+  console.log(`📝 Current Configuration:`);
+  console.log(`   Genre: ${STORY_CONFIG.genre}`);
+  console.log(`   Theme: ${STORY_CONFIG.theme}`);
+  console.log(`   Tone: ${STORY_CONFIG.tone}`);
+  if (STORY_CONFIG.lengthControl?.enabled) {
+    console.log(`\n⚡ Dynamic Length Control: ENABLED`);
+    console.log(`   The AI will subtly adjust story length based on quality:`);
+    console.log(`   • Excellent stories → Extended narrative (${STORY_CONFIG.lengthControl.targetLengths.excellent})`);
+    console.log(`   • Good stories → Normal pacing (${STORY_CONFIG.lengthControl.targetLengths.good})`);
+    console.log(`   • Weak stories → Graceful wrap-up (${STORY_CONFIG.lengthControl.targetLengths.poor})`);
+  }
+  console.log();
+
+  playGame().catch(console.error);
+}