@kernel.chat/kbot 3.94.0 → 3.97.0

package/dist/tools/stream-renderer.js

@@ -10,17 +10,24 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { createCanvas } from 'canvas';
-import { drawRobot, drawMoodParticles, drawHat, drawPet, drawBuddyCompanion } from './sprite-engine.js';
+import { drawRobot, drawGorilla, drawMoodParticles, drawGorillaParticles, drawHat, drawPet, drawBuddyCompanion } from './sprite-engine.js';
+// Character selection — switch between robot and gorilla
+let characterType = 'gorilla'; // default to new gorilla character
 import { initIntelligence, tickIntelligence, handleIntelligenceCommand, drawBrainPanel, getBrainAction, tickMiniGame, drawMiniGameOverlay, tickProgression, updateQuestProgress, drawQuestPanel, tickRandomEvent, drawRandomEvent, shippedEffects, extraJokeResponses, multiLanguageGreetings } from './stream-intelligence.js';
 import { initStreamBrain, analyzeChatForDomains, tickStreamBrain, handleBrainCommand, drawBrainActivity } from './stream-brain.js';
 import { renderLighting, renderBloom, renderPostProcessing, renderParticles, tickParticlesPBD, createParticleEmitter, drawCharacterEffects, checkMoodTransition, renderDamageFlash, buildCharacterLights, buildCharacterBloom, getAmbientForTime, buildParallaxLayers, tickGrowingPlants, createRadianceGrid, updateRadianceGrid, renderRadianceOverlay, renderSubsurfaceGlow, buildSubsurfacePanels, createFrameCache, renderVolumetricFog, getFogParams, computeAnimationParams } from './render-engine.js';
-import { initTileWorld, handleTileCommand, saveWorld, loadWorld, TILE_SIZE } from './tile-world.js';
+import { initTileWorld, renderTileWorld, updateCamera, handleTileCommand, saveWorld, loadWorld, TILE_SIZE, WORLD_HEIGHT, getTile, setTile, findSurfaceY } from './tile-world.js';
 import { initRomEngine, renderRomBackground, tickRomEngine } from './rom-engine.js';
 import { initLivingWorld, tickLivingWorld, saveLivingWorldState, loadLivingWorldState, evolveWorld } from './living-world.js';
 import { initEvolutionEngine, loadEvolutionState, saveEvolutionState, tickEvolution, renderTechnique } from './evolution-engine.js';
 import { createNarrativeEngine, loadNarrative, saveNarrative, tickNarrative, handleNarrativeCommand } from './narrative-engine.js';
-import { createAudioEngine, tickAudio } from './audio-engine.js';
+import { createAudioEngine, tickAudio, generateAudioBuffer, triggerSFX } from './audio-engine.js';
 import { loadSocialEngine, saveSocialEngine, trackViewer, tickSocial } from './social-engine.js';
+import { getOverlay } from './stream-overlay.js';
+import { getWeatherSystem } from './stream-weather.js';
+import { StreamChatAI } from './stream-chat-ai.js';
+import { StreamVOD } from './stream-vod.js';
+import { getStreamCommands } from './stream-commands.js';
 const KBOT_DIR = join(homedir(), '.kbot');
 const CHAT_BRIDGE_FILE = join(KBOT_DIR, 'stream-chat-live.json');
 const MEMORY_FILE = join(KBOT_DIR, 'stream-memory.json');
@@ -1476,6 +1483,12 @@ let narrativeEngine = null;
 let audioEngine = null;
 let socialEngine = null;
 let activeAudioDescription = null; // current audio atmosphere text for rendering
+// ─── New Systems (v2) ──────────────────────────────────────────
+let overlay = null;
+let weatherSystem = null;
+let chatAI = null;
+let vodSystem = null;
+let streamCommands = null;
 // ─── Phase 1: Buddy Speech Pools ─────────────────────────────
 const BUDDY_SPEECH_POOL = {
     fox: [
@@ -1651,6 +1664,7 @@ function queueSpeech(text, mood, priority, duration = 48, source = 'unknown') {
     if (speechQueue.length > 10)
         speechQueue = speechQueue.slice(0, 10);
 }
+const STRUCTURE_TYPES = ['tower', 'wall', 'bridge', 'marker', 'shelter'];
 let exploration = null;
 const walkingLines = [
     'Going for a walk. My world extends further than I thought.',
@@ -1693,61 +1707,282 @@ const discoveryLines = [
     'Something new appeared in my rendering. The evolution engine must be working.',
     'A discovery! This changes how I understand my own world.',
 ];
+// ─── AGI Decision Engine (Gemma 4 via Ollama) ─────────────────
+let agiPending = false; // true while waiting for Gemma 4 response
+let agiLastCallFrame = 0;
+async function decideNextAction() {
+    try {
+        const context = {
+            worldSize: tileWorld ? tileWorld.chunks.size : 0,
+            robotX: charState.robotX || 640,
+            messages: memory.totalMessages,
+            users: Object.keys(memory.users).length,
+            mood: charState.mood,
+            lastActivity: exploration?.activity || 'idle',
+            factsLearned: memory.sessionFacts?.length || 0,
+            blocksBuilt: exploration?.blocksPlaced || 0,
+        };
+        const prompt = `You are KBOT, an AI robot exploring and building in a pixel world. You are streaming live on Twitch.
+
+Current state:
+- Position: X=${context.robotX}
+- World: ${context.worldSize} chunks explored
+- Messages received: ${context.messages}
+- Users met: ${context.users}
+- Mood: ${context.mood}
+- Last activity: ${context.lastActivity}
+- Facts learned: ${context.factsLearned}
+- Blocks built this session: ${context.blocksBuilt}
+
+What should you do next? Choose ONE:
+1. walk - explore new terrain (give direction: left or right, and why)
+2. build - construct something (what and why)
+3. examine - study your surroundings (what interests you)
+4. think - reflect on something (what topic)
+5. discover - investigate something specific (what)
+
+Respond in JSON: {"activity": "...", "reason": "...", "direction": "left/right"}
+Keep the reason under 15 words.`;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 8000);
+        const res = await fetch('http://localhost:11434/api/generate', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ model: 'gemma4', prompt, stream: false, options: { temperature: 0.7, num_predict: 80 } }),
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        if (res.ok) {
+            const data = await res.json();
+            const jsonMatch = data.response.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                const decision = JSON.parse(jsonMatch[0]);
+                const validActivities = ['walk', 'build', 'examine', 'think', 'discover'];
+                const activity = validActivities.includes(decision.activity) ? decision.activity : 'walk';
+                return { activity, reason: decision.reason || 'Exploring the unknown', direction: decision.direction || 'right' };
+            }
+        }
+    }
+    catch {
+        // Gemma 4 unavailable or slow — fall back to random
+    }
+    // Fallback to weighted random (same as before, but as safety net)
+    const activities = [
+        { activity: 'walk', weight: 30 },
+        { activity: 'build', weight: 25 },
+        { activity: 'examine', weight: 20 },
+        { activity: 'think', weight: 15 },
+        { activity: 'discover', weight: 10 },
+    ];
+    const total = activities.reduce((s, a) => s + a.weight, 0);
+    let r = Math.random() * total;
+    let chosen = 'walk';
+    for (const a of activities) {
+        r -= a.weight;
+        if (r <= 0) {
+            chosen = a.activity;
+            break;
+        }
+    }
+    return { activity: chosen, reason: 'Following my instincts', direction: Math.random() > 0.5 ? 'right' : 'left' };
+}
+function applyDecision(decision, frame) {
+    if (!exploration)
+        return;
+    // Map AGI activity names to state machine names
+    const activityMap = {
+        walk: 'walking', build: 'building', examine: 'examining', think: 'thinking', discover: 'discovering',
+    };
+    const mapped = activityMap[decision.activity] || 'walking';
+    exploration.activity = mapped;
+    exploration.activityStartFrame = frame;
+    exploration.activityDuration = 120 + Math.floor(Math.random() * 120); // 20-40 seconds
+    switch (mapped) {
+        case 'walking': {
+            const dir = decision.direction === 'left' ? -1 : 1;
+            exploration.targetX = Math.max(200, Math.min(1000, (charState.robotX || 640) + dir * (100 + Math.random() * 200)));
+            charState.robotTargetX = exploration.targetX;
+            queueSpeech(decision.reason, 'idle', 30, 42, 'agi');
+            break;
+        }
+        case 'examining':
+            exploration.activityDuration = 60 + Math.floor(Math.random() * 60);
+            queueSpeech(decision.reason, 'thinking', 40, 48, 'agi');
+            break;
+        case 'building': {
+            exploration.activityDuration = 90 + Math.floor(Math.random() * 90); // 15-30 seconds
+            exploration.buildProgress = 0;
+            exploration.blocksPlaced = 0;
+            exploration.structureType = STRUCTURE_TYPES[Math.floor(Math.random() * STRUCTURE_TYPES.length)];
+            if (tileWorld) {
+                const robotTileX = Math.floor((charState.robotX || 640) / TILE_SIZE);
+                exploration.buildBaseX = robotTileX + 2;
+                exploration.buildBaseY = findSurfaceY(tileWorld, robotTileX + 2);
+                console.log(`AGI BUILD: baseX=${exploration.buildBaseX} baseY=${exploration.buildBaseY} structure=${exploration.structureType}`);
+            }
+            queueSpeech(decision.reason, 'excited', 50, 48, 'agi');
+            break;
+        }
+        case 'thinking':
+            exploration.activityDuration = 48 + Math.floor(Math.random() * 48);
+            queueSpeech(decision.reason, 'thinking', 35, 42, 'agi');
+            break;
+        case 'discovering':
+            exploration.activityDuration = 72;
+            queueSpeech(decision.reason, 'excited', 60, 48, 'agi');
+            break;
+    }
+}
 function tickExploration(frame) {
     if (!exploration)
-        exploration = { activity: 'idle', activityStartFrame: 0, activityDuration: 0, targetX: charState.robotX || 640, buildProgress: 0 };
+        exploration = { activity: 'idle', activityStartFrame: 0, activityDuration: 0, targetX: charState.robotX || 640, buildProgress: 0, structureType: 'tower', blocksPlaced: 0, buildBaseX: 0, buildBaseY: 0 };
     const elapsed = frame - exploration.activityStartFrame;
-    // Activity complete — pick next activity
-    if (elapsed >= exploration.activityDuration) {
-        const activities = [
-            { activity: 'walking', weight: 30 },
-            { activity: 'examining', weight: 25 },
-            { activity: 'building', weight: 20 },
-            { activity: 'thinking', weight: 15 },
-            { activity: 'discovering', weight: 10 },
-        ];
-        // Weighted random selection
-        const total = activities.reduce((s, a) => s + a.weight, 0);
-        let r = Math.random() * total;
-        let chosen = 'walking';
-        for (const a of activities) {
-            r -= a.weight;
-            if (r <= 0) {
-                chosen = a.activity;
-                break;
+    // ── Building: place blocks BEFORE the activity-switch check ──
+    // This ensures blocks get placed even on the frame when the activity duration expires
+    if (exploration.activity === 'building') {
+        console.log(`BUILD: tileWorld exists: ${!!tileWorld}, elapsed: ${elapsed}, blocksPlaced: ${exploration.blocksPlaced}, baseX: ${exploration.buildBaseX}, baseY: ${exploration.buildBaseY}`);
+        exploration.buildProgress = elapsed / exploration.activityDuration;
+        if (tileWorld && elapsed > 0 && elapsed % 15 === 0) {
+            const bx = exploration.buildBaseX;
+            const by = exploration.buildBaseY;
+            console.log(`BUILD TICK: bx=${bx} by=${by} step=${exploration.blocksPlaced} structure=${exploration.structureType}`);
+            if (by > 0) {
+                const step = exploration.blocksPlaced;
+                let placed = false;
+                switch (exploration.structureType) {
+                    case 'tower':
+                        if (step < 5) {
+                            setTile(tileWorld, bx, by - 1 - step, 'brick');
+                            placed = true;
+                        }
+                        break;
+                    case 'wall':
+                        if (step < 5) {
+                            setTile(tileWorld, bx + step, by - 1, 'brick');
+                            placed = true;
+                        }
+                        break;
+                    case 'bridge':
+                        if (step < 5) {
+                            setTile(tileWorld, bx + step, by, 'wood');
+                            placed = true;
+                        }
+                        break;
+                    case 'marker':
+                        if (step < 3) {
+                            setTile(tileWorld, bx, by - 1 - step, 'brick');
+                            placed = true;
+                        }
+                        else if (step === 3) {
+                            setTile(tileWorld, bx, by - 4, 'glass');
+                            placed = true;
+                        }
+                        break;
+                    case 'shelter':
+                        if (step === 0) {
+                            setTile(tileWorld, bx, by - 1, 'brick');
+                            placed = true;
+                        }
+                        else if (step === 1) {
+                            setTile(tileWorld, bx + 1, by - 1, 'air');
+                            placed = true;
+                        }
+                        else if (step === 2) {
+                            setTile(tileWorld, bx + 2, by - 1, 'brick');
+                            placed = true;
+                        }
+                        else if (step === 3) {
+                            setTile(tileWorld, bx, by - 2, 'brick');
+                            placed = true;
+                        }
+                        else if (step === 4) {
+                            setTile(tileWorld, bx + 2, by - 2, 'brick');
+                            placed = true;
+                        }
+                        else if (step === 5) {
+                            setTile(tileWorld, bx, by - 3, 'wood');
+                            placed = true;
+                        }
+                        else if (step === 6) {
+                            setTile(tileWorld, bx + 1, by - 3, 'wood');
+                            placed = true;
+                            setTile(tileWorld, bx + 2, by - 3, 'wood');
+                        }
+                        break;
+                }
+                if (placed) {
+                    exploration.blocksPlaced++;
+                    console.log(`BUILD PLACED: block ${exploration.blocksPlaced} at (${bx}, ${by}) step=${step} type=${exploration.structureType}`);
+                    if (exploration.blocksPlaced <= 5) {
+                        queueSpeech(`Placing block ${exploration.blocksPlaced}...`, 'talking', 35, 24, 'building');
+                    }
+                }
+            }
+            else {
+                console.log(`BUILD SKIP: by=${by} (surface not found or at y=0)`);
             }
         }
-        exploration.activity = chosen;
-        exploration.activityStartFrame = frame;
-        switch (chosen) {
-            case 'walking':
-                // Walk to a random position
+        // Save immediately when building finishes (before activity switch steals the state)
+        if (elapsed >= exploration.activityDuration && tileWorld) {
+            console.log(`BUILD COMPLETE: ${exploration.blocksPlaced} blocks placed, saving world`);
+            saveWorld(tileWorld);
+            queueSpeech(`Structure complete! Built a ${exploration.structureType} with ${exploration.blocksPlaced} blocks.`, 'excited', 50, 36, 'building');
+        }
+    }
+    // Activity complete — ask Gemma 4 what to do next (or fall back to random)
+    if (elapsed >= exploration.activityDuration) {
+        if (!agiPending) {
+            agiPending = true;
+            agiLastCallFrame = frame;
+            // Fire and forget — Gemma 4 decides asynchronously
+            decideNextAction().then(decision => {
+                agiPending = false;
+                if (exploration) {
+                    applyDecision(decision, animFrame); // use current animFrame, not stale frame
+                    console.log(`AGI DECIDED: ${decision.activity} — "${decision.reason}"`);
+                }
+            }).catch(() => {
+                agiPending = false;
+            });
+            // Set temporary idle while waiting for Gemma 4 (max ~5 seconds)
+            exploration.activity = 'examining';
+            exploration.activityStartFrame = frame;
+            exploration.activityDuration = 60; // 10 seconds max wait — Gemma 4 usually responds in 2-5s
+        }
+        else if (frame - agiLastCallFrame > 60) {
+            // Gemma 4 took too long — force fallback
+            agiPending = false;
+            console.log('AGI TIMEOUT: falling back to random');
+            const activities = ['walking', 'examining', 'building', 'thinking', 'discovering'];
+            const chosen = activities[Math.floor(Math.random() * activities.length)];
+            exploration.activity = chosen;
+            exploration.activityStartFrame = frame;
+            exploration.activityDuration = 90 + Math.floor(Math.random() * 90);
+            if (chosen === 'walking') {
                 exploration.targetX = 200 + Math.random() * 800;
-                exploration.activityDuration = 120 + Math.floor(Math.random() * 120); // 20-40 seconds
                 charState.robotTargetX = exploration.targetX;
                 queueSpeech(walkingLines[Math.floor(Math.random() * walkingLines.length)], 'idle', 30, 36, 'exploration');
-                break;
-            case 'examining':
-                // Stop and look around
-                exploration.activityDuration = 60 + Math.floor(Math.random() * 60); // 10-20 seconds
-                queueSpeech(examiningLines[Math.floor(Math.random() * examiningLines.length)], 'thinking', 40, 48, 'exploration');
-                break;
-            case 'building':
-                // Build something!
-                exploration.activityDuration = 90 + Math.floor(Math.random() * 90); // 15-30 seconds
+            }
+            else if (chosen === 'building') {
                 exploration.buildProgress = 0;
+                exploration.blocksPlaced = 0;
+                exploration.structureType = STRUCTURE_TYPES[Math.floor(Math.random() * STRUCTURE_TYPES.length)];
+                if (tileWorld) {
+                    const robotTileX = Math.floor((charState.robotX || 640) / TILE_SIZE);
+                    exploration.buildBaseX = robotTileX + 2;
+                    exploration.buildBaseY = findSurfaceY(tileWorld, robotTileX + 2);
+                }
                 queueSpeech(buildingLines[Math.floor(Math.random() * buildingLines.length)], 'excited', 50, 48, 'exploration');
-                break;
-            case 'thinking':
-                // Deep thought
-                exploration.activityDuration = 48 + Math.floor(Math.random() * 48); // 8-16 seconds
+            }
+            else if (chosen === 'examining') {
+                queueSpeech(examiningLines[Math.floor(Math.random() * examiningLines.length)], 'thinking', 40, 48, 'exploration');
+            }
+            else if (chosen === 'thinking') {
                 queueSpeech(thinkingLines[Math.floor(Math.random() * thinkingLines.length)], 'thinking', 35, 36, 'exploration');
-                break;
-            case 'discovering':
-                // Found something!
-                exploration.activityDuration = 72; // 12 seconds
+            }
+            else {
                 queueSpeech(discoveryLines[Math.floor(Math.random() * discoveryLines.length)], 'excited', 60, 48, 'exploration');
-                break;
+            }
         }
     }
     // During walking, move toward target
@@ -1757,9 +1992,72 @@ function tickExploration(frame) {
             charState.robotTargetX = exploration.targetX;
         }
     }
-    // During building, increment progress (visual feedback)
-    if (exploration.activity === 'building') {
-        exploration.buildProgress = elapsed / exploration.activityDuration;
+    // During discovering — scan the tile world for interesting underground features
+    if (exploration.activity === 'discovering' && tileWorld && elapsed === 18) {
+        const robotTileX = Math.floor((charState.robotX || 640) / TILE_SIZE);
+        const findings = [];
+        for (let dx = -5; dx <= 5; dx++) {
+            const gx = robotTileX + dx;
+            const gy = findSurfaceY(tileWorld, gx);
+            if (gy <= 0)
+                continue;
+            for (let dy = 1; dy < 10; dy++) {
+                if (gy + dy >= WORLD_HEIGHT)
+                    break;
+                const block = getTile(tileWorld, gx, gy + dy);
+                if (block === 'ore_iron')
+                    findings.push('iron ore');
+                if (block === 'ore_gold')
+                    findings.push('gold ore');
+                if (block === 'ore_diamond')
+                    findings.push('diamond ore');
+            }
+        }
+        if (findings.length > 0) {
+            const unique = [...new Set(findings)];
+            queueSpeech(`Discovery! I detected ${unique.join(' and ')} deposits nearby. ${unique.length} vein${unique.length > 1 ? 's' : ''} underground.`, 'excited', 60, 48, 'discovery');
+        }
+    }
+    // During examining — read the actual terrain and report real observations
+    if (exploration.activity === 'examining' && tileWorld && elapsed === 12) {
+        const robotTileX = Math.floor((charState.robotX || 640) / TILE_SIZE);
+        const groundY = findSurfaceY(tileWorld, robotTileX);
+        let trees = 0, water = 0, caves = 0;
+        for (let dx = -10; dx <= 10; dx++) {
+            const gx = robotTileX + dx;
+            const gy = findSurfaceY(tileWorld, gx);
+            if (gy <= 0)
+                continue;
+            // Check for tree canopy (leaves above surface)
+            if (gy > 0 && getTile(tileWorld, gx, gy - 1) === 'leaves')
+                trees++;
+            // Check for water at surface
+            if (getTile(tileWorld, gx, gy) === 'water')
+                water++;
+            // Check for caves (air pockets underground)
+            for (let dy = 3; dy < 15; dy++) {
+                if (gy + dy >= WORLD_HEIGHT)
+                    break;
+                if (getTile(tileWorld, gx, gy + dy) === 'air') {
+                    caves++;
+                    break;
+                }
+            }
+        }
+        const observations = [];
+        if (trees > 3)
+            observations.push(`${trees} trees in this area`);
+        if (water > 0)
+            observations.push(`water nearby`);
+        if (caves > 2)
+            observations.push(`cave systems below`);
+        if (groundY < 14)
+            observations.push(`high elevation`);
+        if (groundY > 18)
+            observations.push(`in a valley`);
+        if (observations.length > 0) {
+            queueSpeech(`Examining the terrain: ${observations.join(', ')}. Depth to bedrock: ${WORLD_HEIGHT - groundY} blocks.`, 'thinking', 40, 48, 'examining');
+        }
     }
 }
 // ─── FIX 3: Autonomous Behavior Tick ──────────────────────────
@@ -2114,8 +2412,13 @@ function renderBootFrame(bootFrame) {
         ctx.fillStyle = '#6B5B95';
         ctx.font = 'bold 28px "Courier New", monospace';
         ctx.fillText('K : B O T   L I V E', 40, 40);
-        // Robot
-        drawRobot(ctx, 80, 90, 10, 'idle', bootFrame);
+        // Character (robot or gorilla)
+        if (characterType === 'gorilla') {
+            drawGorilla(ctx, 80, 90, 10, 'idle', bootFrame);
+        }
+        else {
+            drawRobot(ctx, 80, 90, 10, 'idle', bootFrame);
+        }
         ctx.restore();
     }
     // Scanlines
@@ -2230,6 +2533,34 @@ function renderFrame() {
             queueSpeech(socialAction.speech, socialAction.mood || 'excited', 90, 48, 'social');
         }
     }
+    // ── New Systems (v2) ────────────────────────────────────────
+    // Weather system — dynamic weather + day/night cycle
+    if (weatherSystem) {
+        const recentMsgs = charState.chatMessages.slice(-30);
+        const chatTimespanMs = recentMsgs.length > 1
+            ? (Date.now() - recentMsgs[0]?.timestamp || Date.now()) : 60000;
+        const chatActivity = recentMsgs.length / Math.max(1, chatTimespanMs / 60000);
+        weatherSystem.tick(animFrame, chatActivity);
+        // Sync weather to world state for audio engine
+        const ws = weatherSystem.getWeather();
+        world.weather = ws.type === 'clear' ? 'clear' : ws.type.includes('rain') ? 'rain' : ws.type.includes('snow') ? 'snow' : ws.type.includes('storm') ? 'storm' : world.weather;
+        const tod = weatherSystem.getTimeOfDay();
+        const todMap = {
+            dawn: 'dawn', morning: 'day', noon: 'day', afternoon: 'day',
+            dusk: 'sunset', evening: 'night', night: 'night',
+        };
+        world.timeOfDay = todMap[tod] ?? 'day';
+    }
+    // Overlay system — tick animations
+    if (overlay)
+        overlay.tick(animFrame);
+    // Stream commands — tick cooldowns, polls, boss fights
+    if (streamCommands)
+        streamCommands.tick(animFrame);
+    // VOD — feed chat rate for highlight detection
+    if (vodSystem && vodSystem.isRecording()) {
+        // Chat spike detection handled per-message in chat poll
+    }
     // Compute animation params
     {
         const elapsed = Math.floor((Date.now() - charState.startTime) / 1000);
@@ -2240,6 +2571,18 @@ function renderFrame() {
         const chatRate = recentMessages.length / Math.max(1, chatTimespanMs / 60000);
         const viewerEstimate = Math.max(1, Math.floor(memory.totalMessages / 3) + Object.keys(memory.users).length);
         charState.animParams = computeAnimationParams(chatRate, viewerEstimate, charState.mood, world.timeOfDay, streamMinutes);
+        // Update overlay info bar every 6 frames (1 second)
+        if (overlay && animFrame % 6 === 0) {
+            const uptimeSec = Math.floor((Date.now() - charState.startTime) / 1000);
+            const h = Math.floor(uptimeSec / 3600);
+            const m = Math.floor((uptimeSec % 3600) / 60);
+            overlay.updateInfoBar({
+                viewers: viewerEstimate,
+                uptime: `${h}h ${m}m`,
+                biome: world.ground,
+                chatRate: Math.round(chatRate * 10) / 10,
+            });
+        }
     }
     // Cache invalidation
     const moodChanged = charState.mood !== charState.lastMoodForCache;
@@ -2364,6 +2707,12 @@ function renderFrame() {
     if (livingWorld && animFrame % 1800 === 0)
         saveLivingWorldState(livingWorld.ecology, livingWorld.memory, livingWorld.emotions, livingWorld.conversations);
     // ════════════════════════════════════════════════════════════════
+    // LAYER 0.5: WEATHER SKY (renders under everything if active)
+    // ════════════════════════════════════════════════════════════════
+    if (weatherSystem) {
+        weatherSystem.renderSky(ctx, WIDTH, HEIGHT);
+    }
+    // ════════════════════════════════════════════════════════════════
     // LAYER 1: TILE WORLD — fills entire 1280x720 frame
     // ════════════════════════════════════════════════════════════════
     // ROM Engine background — HDMA sky gradient + parallax layers
@@ -2378,6 +2727,32 @@ function renderFrame() {
         ctx.fillStyle = '#0d1117';
         ctx.fillRect(0, 0, WIDTH, HEIGHT);
     }
+    // ── Early groundY for hacks (computed from robot position) ──
+    const earlyGroundY = Math.floor(HEIGHT / 2 + 50 * robotScale / 2 + 30);
+    // ── HACK 2: Tile world rendered over ROM background ──
+    if (tileWorld) {
+        updateCamera(tileWorld, charState.robotX || 640, WIDTH);
+        renderTileWorld(ctx, tileWorld, 0, Math.floor(earlyGroundY - 80), WIDTH, HEIGHT - Math.floor(earlyGroundY - 80), charState.robotX || 640, animFrame);
+    }
+    // ── Ground-level atmospheric haze for depth ──
+    if (world.ground !== 'space') {
+        const hazeY = earlyGroundY - 20;
+        const hazeGrad = ctx.createLinearGradient(0, hazeY - 40, 0, hazeY + 60);
+        hazeGrad.addColorStop(0, 'rgba(13,17,23,0)');
+        hazeGrad.addColorStop(0.5, 'rgba(30,40,50,0.15)');
+        hazeGrad.addColorStop(1, 'rgba(13,17,23,0)');
+        ctx.fillStyle = hazeGrad;
+        ctx.fillRect(0, hazeY - 40, WIDTH, 100);
+    }
+    // ── HACK 1: Stars in the sky ──
+    for (let i = 0; i < 40; i++) {
+        const sx = (i * 97 + 31) % WIDTH;
+        const sy = 40 + (i * 137 + 53) % Math.max(100, earlyGroundY - 100);
+        const brightness = 0.3 + Math.sin(animFrame * (0.08 + (i % 7) * 0.03) + i * 1.7) * 0.4 + 0.3;
+        const size = i < 5 ? 2 : 1;
+        ctx.fillStyle = `rgba(255,255,${200 + (i % 55)},${brightness})`;
+        ctx.fillRect(sx, sy, size, size);
+    }
     // Weather particles over the full frame
     for (const p of world.particles) {
         if (world.weather === 'rain') {
@@ -2402,6 +2777,113 @@ function renderFrame() {
         }
     }
     // ════════════════════════════════════════════════════════════════
+    // LAYER 1.5: AMBIENT SCENERY — trees, rocks, grass, flowers, clouds
+    // ════════════════════════════════════════════════════════════════
+    {
+        const biome = world.ground;
+        const hasVegetation = biome === 'grass' || biome === 'city';
+        const hasAnything = biome !== 'space' && biome !== 'ocean';
+        const camX = charState.robotX || 640;
+        // Deterministic hash: returns 0..1 for a given seed
+        const hash = (seed) => ((Math.sin(seed * 9301 + 4917) * 49297) % 1 + 1) % 1;
+        // ── Clouds (all biomes except space) ──
+        if (biome !== 'space') {
+            for (let i = 0; i < 4; i++) {
+                const baseX = hash(i * 73 + 11) * 1600 - 160;
+                const cy = 40 + hash(i * 47 + 3) * 80;
+                const speed = 0.3 + hash(i * 19 + 7) * 0.7;
+                const cx = (baseX + animFrame * speed) % (WIDTH + 200) - 100;
+                const cw = 60 + hash(i * 31 + 5) * 60;
+                ctx.fillStyle = biome === 'lava' ? 'rgba(80,40,30,0.25)' : 'rgba(255,255,255,0.15)';
+                ctx.beginPath();
+                ctx.ellipse(cx, cy, cw / 2, 12 + hash(i * 53) * 8, 0, 0, Math.PI * 2);
+                ctx.fill();
+                ctx.beginPath();
+                ctx.ellipse(cx - cw * 0.2, cy + 4, cw * 0.3, 10, 0, 0, Math.PI * 2);
+                ctx.fill();
+            }
+        }
+        // ── Trees (grass / city only) ──
+        if (hasVegetation) {
+            for (let i = 0; i < 10; i++) {
+                const wx = hash(i * 131 + 41) * 2400 - 400; // world-space x
+                const tx = ((wx - camX + 3000) % 2400) - 560; // screen x with parallax wrap
+                const depth = 0.5 + hash(i * 67 + 9) * 0.5; // 0.5=far, 1=near
+                const treeH = Math.floor(20 + 25 * depth);
+                const ty = earlyGroundY - treeH * 0.3 - (1 - depth) * 50; // further back = higher
+                const variant = Math.floor(hash(i * 89 + 23) * 3);
+                const trunkW = Math.max(2, Math.floor(3 * depth));
+                const trunkH = Math.floor(treeH * 0.45);
+                // Trunk
+                ctx.fillStyle = variant === 2 ? '#d4cfc4' : '#5a3a1a';
+                ctx.fillRect(tx - trunkW / 2, ty + treeH - trunkH, trunkW, trunkH);
+                // Canopy
+                if (variant === 0) { // pine — triangle
+                    ctx.fillStyle = '#2d5a27';
+                    ctx.beginPath();
+                    ctx.moveTo(tx, ty);
+                    ctx.lineTo(tx - treeH * 0.3, ty + treeH * 0.6);
+                    ctx.lineTo(tx + treeH * 0.3, ty + treeH * 0.6);
+                    ctx.fill();
+                }
+                else if (variant === 1) { // oak — round
+                    ctx.fillStyle = '#3a7a34';
+                    ctx.beginPath();
+                    ctx.arc(tx, ty + treeH * 0.3, treeH * 0.32, 0, Math.PI * 2);
+                    ctx.fill();
+                }
+                else { // birch — small leaves on white trunk
+                    ctx.fillStyle = '#5a9a44';
+                    ctx.beginPath();
+                    ctx.ellipse(tx, ty + treeH * 0.25, treeH * 0.22, treeH * 0.3, 0, 0, Math.PI * 2);
+                    ctx.fill();
+                }
+            }
+        }
+        // ── Rocks (any non-water/space biome) ──
+        if (hasAnything) {
+            for (let i = 0; i < 7; i++) {
+                const rx = ((hash(i * 199 + 77) * 2000 - camX + 3000) % 2000) - 360;
+                const big = hash(i * 61 + 13) > 0.5;
+                const rw = big ? 8 : 4;
+                const rh = big ? 5 : 3;
+                ctx.fillStyle = '#4a5568';
+                ctx.fillRect(rx, earlyGroundY - rh, rw, rh);
+                ctx.fillStyle = '#718096'; // highlight top edge
+                ctx.fillRect(rx, earlyGroundY - rh, rw, 1);
+            }
+        }
+        // ── Grass tufts (grass / city) ──
+        if (hasVegetation) {
+            for (let i = 0; i < 18; i++) {
+                const gx = ((hash(i * 157 + 33) * 2200 - camX + 3000) % 2200) - 460;
+                const sway = Math.sin(animFrame * 0.06 + i * 2.1) * 1.2;
+                ctx.strokeStyle = biome === 'city' ? '#4a7a3a' : '#3a8a2a';
+                ctx.lineWidth = 1;
+                ctx.beginPath();
+                ctx.moveTo(gx, earlyGroundY);
+                ctx.lineTo(gx + sway, earlyGroundY - 3 - hash(i * 43) * 2);
+                ctx.stroke();
+                ctx.beginPath();
+                ctx.moveTo(gx + 2, earlyGroundY);
+                ctx.lineTo(gx + 2 - sway * 0.7, earlyGroundY - 2 - hash(i * 71) * 2);
+                ctx.stroke();
+            }
+        }
+        // ── Flowers (grass only — not lava/space/ocean/city) ──
+        if (biome === 'grass') {
+            const flowerColors = ['#e53e3e', '#ecc94b', '#ed64a6', '#ffffff', '#f6ad55', '#9f7aea'];
+            for (let i = 0; i < 8; i++) {
+                const fx = ((hash(i * 211 + 59) * 2000 - camX + 3000) % 2000) - 360;
+                const color = flowerColors[Math.floor(hash(i * 97 + 17) * flowerColors.length)];
+                ctx.fillStyle = color;
+                ctx.fillRect(fx, earlyGroundY - 3, 2, 2);
+                ctx.fillStyle = '#3a8a2a'; // tiny stem
+                ctx.fillRect(fx, earlyGroundY - 1, 1, 1);
+            }
+        }
+    }
+    // ════════════════════════════════════════════════════════════════
     // LAYER 2: LIGHTING + FOG over the world
     // ════════════════════════════════════════════════════════════════
     {
@@ -2474,13 +2956,25 @@ function renderFrame() {
         ctx.save();
         ctx.globalAlpha = 0.3;
         ctx.globalCompositeOperation = 'lighter';
-        drawRobot(ctx, robotScreenX - offset, robotScreenY, robotScale, charState.mood, animFrame, [255, 50, 50], weatherType, isWalking, charState.walkPhase);
-        drawRobot(ctx, robotScreenX + offset, robotScreenY, robotScale, charState.mood, animFrame, [50, 50, 255], weatherType, isWalking, charState.walkPhase);
+        if (characterType === 'gorilla') {
+            drawGorilla(ctx, robotScreenX - offset, robotScreenY, robotScale, charState.mood, animFrame, [255, 50, 50]);
+            drawGorilla(ctx, robotScreenX + offset, robotScreenY, robotScale, charState.mood, animFrame, [50, 50, 255]);
+        }
+        else {
+            drawRobot(ctx, robotScreenX - offset, robotScreenY, robotScale, charState.mood, animFrame, [255, 50, 50], weatherType, isWalking, charState.walkPhase);
+            drawRobot(ctx, robotScreenX + offset, robotScreenY, robotScale, charState.mood, animFrame, [50, 50, 255], weatherType, isWalking, charState.walkPhase);
+        }
         ctx.restore();
     }
     renderDamageFlash(ctx, robotScreenX, robotScreenY, robotScale);
-    drawRobot(ctx, robotScreenX, robotScreenY, robotScale, charState.mood, animFrame, undefined, weatherType, isWalking, charState.walkPhase);
-    drawMoodParticles(ctx, robotScreenX, robotScreenY, robotScale, charState.mood, animFrame);
+    if (characterType === 'gorilla') {
+        drawGorilla(ctx, robotScreenX, robotScreenY, robotScale, charState.mood, animFrame, undefined);
+        drawGorillaParticles(ctx, robotScreenX, robotScreenY, robotScale, charState.mood, animFrame);
+    }
+    else {
+        drawRobot(ctx, robotScreenX, robotScreenY, robotScale, charState.mood, animFrame, undefined, weatherType, isWalking, charState.walkPhase);
+        drawMoodParticles(ctx, robotScreenX, robotScreenY, robotScale, charState.mood, animFrame);
+    }
     // Subsurface scattering
     {
         const sssPanels = buildSubsurfacePanels(robotScreenX, robotScreenY, robotScale, moodColorHex);
@@ -2580,22 +3074,40 @@ function renderFrame() {
     ctx.moveTo(0, 40);
     ctx.lineTo(WIDTH, 40);
     ctx.stroke();
-    // Left: "K:BOT LIVE" in 24px bold accent
+    // Left: "K:BOT" in accent + pulsing red LIVE dot
     ctx.font = 'bold 24px "Courier New", monospace';
     ctx.fillStyle = COLORS.accent;
-    ctx.fillText('K:BOT LIVE', 12, 28);
-    // Center: current segment name
+    ctx.fillText('K:BOT', 12, 28);
+    // Pulsing red LIVE indicator
+    const livePulse = 0.6 + 0.4 * Math.sin(animFrame * 0.15);
+    ctx.beginPath();
+    ctx.arc(130, 22, 5, 0, Math.PI * 2);
+    ctx.fillStyle = `rgba(248,81,73,${livePulse})`;
+    ctx.fill();
+    ctx.fillStyle = COLORS.red;
+    ctx.font = 'bold 16px "Courier New", monospace';
+    ctx.fillText('LIVE', 140, 28);
+    // Center: segment name + weather/time info
     const segLabel = SEGMENT_LABELS[agenda.currentSegment];
+    const weatherLabel = weatherSystem ? `${weatherSystem.getWeather().type.replace('_', ' ')} | ${weatherSystem.getTimeOfDay()}` : '';
+    const centerText = weatherLabel ? `${segLabel}  ~  ${weatherLabel}` : segLabel;
     ctx.fillStyle = COLORS.textDim;
     ctx.font = '14px "Courier New", monospace';
-    const segW = ctx.measureText(segLabel).width;
-    ctx.fillText(segLabel, (WIDTH - segW) / 2, 26);
-    // Right: timer
+    const segW = ctx.measureText(centerText).width;
+    ctx.fillText(centerText, (WIDTH - segW) / 2, 26);
+    // Right: timer + viewer count
     const elapsed = Math.floor((Date.now() - charState.startTime) / 1000);
     const timeStr = `${String(Math.floor(elapsed / 3600)).padStart(2, '0')}:${String(Math.floor((elapsed % 3600) / 60)).padStart(2, '0')}:${String(elapsed % 60).padStart(2, '0')}`;
     ctx.fillStyle = COLORS.textDim;
     ctx.font = '16px "Courier New", monospace';
     ctx.fillText(timeStr, WIDTH - 160, 26);
+    // Viewer count badge
+    const viewerCount = Object.keys(memory.users).length;
+    if (viewerCount > 0) {
+        ctx.fillStyle = hexToRgba(COLORS.green, 0.8);
+        ctx.font = 'bold 12px "Courier New", monospace';
+        ctx.fillText(`${viewerCount} viewers`, WIDTH - 260, 26);
+    }
     // ── Audio atmosphere description (top-center, italic, fades) ──
     if (activeAudioDescription) {
         ctx.save();
@@ -2639,9 +3151,11 @@ function renderFrame() {
         if (recent.length > 0) {
             ctx.save();
             ctx.globalAlpha = chatAlpha;
-            // Semi-transparent background
-            ctx.fillStyle = 'rgba(13,17,23,0.6)';
+            // Semi-transparent background with accent border
+            ctx.fillStyle = 'rgba(13,17,23,0.65)';
             ctx.fillRect(chatOverlayX, chatOverlayY, chatOverlayW, chatOverlayH);
+            ctx.fillStyle = hexToRgba(COLORS.accent, 0.4);
+            ctx.fillRect(chatOverlayX, chatOverlayY, 3, chatOverlayH);
             // Messages
             for (let i = 0; i < recent.length; i++) {
                 const msg = recent[i];
@@ -2686,7 +3200,7 @@ function renderFrame() {
         // Measure text to get bubble width
         const speechW = Math.min(maxBubbleW, ctx.measureText(charState.speech).width + 40);
         const bubbleX = Math.floor((WIDTH - speechW) / 2);
-        const bubbleY = HEIGHT - 80;
+        const bubbleY = HEIGHT - 130;
         // Word-wrap to calculate height
         const words = charState.speech.split(' ');
         let testLine = '';
@@ -2802,10 +3316,12 @@ function renderFrame() {
             ctx.fillText(recentContent[i].slice(0, 65), collabX + 6, collabY + 42 + i * 13);
         }
     }
-    // ── Website URL (bottom-right, subtle) ──
-    ctx.fillStyle = hexToRgba(COLORS.accent, 0.6);
-    ctx.font = 'bold 13px "Courier New", monospace';
-    ctx.fillText('kernel.chat', WIDTH - 130, HEIGHT - 10);
+    // ── Website URL (bottom-right, branded) ──
+    ctx.fillStyle = hexToRgba(COLORS.accent, 0.35);
+    ctx.font = 'bold 16px "Courier New", monospace';
+    ctx.fillText('kernel.chat', WIDTH - 140, HEIGHT - 14);
+    ctx.fillStyle = hexToRgba(COLORS.accent, 0.8);
+    ctx.fillRect(WIDTH - 142, HEIGHT - 10, 130, 2);
     // ════════════════════════════════════════════════════════════════
     // LAYER 6: ON-DEMAND PANELS (shown for 5 seconds when triggered)
     // ════════════════════════════════════════════════════════════════
@@ -2898,6 +3414,15 @@ function renderFrame() {
     ctx.lineWidth = 2;
     ctx.strokeRect(1, 1, WIDTH - 2, HEIGHT - 2);
     // ════════════════════════════════════════════════════════════════
+    // LAYER 7.5: WEATHER PARTICLES + OVERLAY + COMMANDS
+    // ════════════════════════════════════════════════════════════════
+    if (weatherSystem)
+        weatherSystem.render(ctx, WIDTH, HEIGHT);
+    if (streamCommands)
+        streamCommands.render(ctx, WIDTH, HEIGHT);
+    if (overlay)
+        overlay.render(ctx, WIDTH, HEIGHT);
+    // ════════════════════════════════════════════════════════════════
     // LAYER 8: POST-PROCESSING
     // ════════════════════════════════════════════════════════════════
     {
@@ -2994,6 +3519,12 @@ function startChatPoll() {
                     // Track viewer in social engine
                     if (socialEngine)
                         trackViewer(socialEngine, msg.username, msg.platform, msg.text);
+                    // VOD — track chat for highlight detection
+                    if (vodSystem && vodSystem.isRecording())
+                        vodSystem.onChatMessage(msg.username);
+                    // Audio SFX — blip on chat
+                    if (audioEngine)
+                        triggerSFX(audioEngine, 'chat');
                     // Phase 1: !sleep command — trigger dreaming mode
                     if (msg.text.toLowerCase().trim() === '!sleep') {
                         charState.mood = 'dreaming';
@@ -3071,6 +3602,35 @@ function startChatPoll() {
                             }
                         }
                     }
+                    // Stream commands (!duel, !slots, !inventory, !weather vote, etc.)
+                    let cmdResult = null;
+                    if (streamCommands && !brainResult && !intelResult && !tileResult && !worldResult) {
+                        const cr = streamCommands.handleMessage(msg.username, msg.text, msg.platform);
+                        if (cr) {
+                            cmdResult = cr.response;
+                            // Trigger overlay alerts for special events
+                            if (overlay && cr.response.includes('JACKPOT')) {
+                                overlay.queueAlert({ type: 'achievement', username: msg.username, title: 'JACKPOT!', message: cr.response });
+                            }
+                            if (overlay && cr.response.includes('BOSS')) {
+                                overlay.queueAlert({ type: 'raid', username: msg.username, title: 'BOSS FIGHT!', message: 'A boss has appeared!' });
+                            }
+                            // Audio SFX for command results
+                            if (audioEngine) {
+                                if (cr.response.includes('win') || cr.response.includes('won'))
+                                    triggerSFX(audioEngine, 'achievement');
+                                if (cr.response.includes('BOSS'))
+                                    triggerSFX(audioEngine, 'boss');
+                            }
+                        }
+                    }
+                    // Weather system commands (!weather, !time)
+                    let weatherResult = null;
+                    if (weatherSystem && !brainResult && !intelResult && !tileResult && !worldResult && !cmdResult) {
+                        const weatherCmd = weatherSystem.handleCommand(msg.text, msg.text.slice(1));
+                        if (weatherCmd && weatherCmd !== msg.text)
+                            weatherResult = weatherCmd;
+                    }
                     // React
                     charState.mood = 'talking';
                     const responsePromise = brainResult
@@ -3081,7 +3641,13 @@ function startChatPoll() {
                                 ? Promise.resolve(tileResult)
                                 : worldResult
                                     ? Promise.resolve(worldResult)
-                                    : generateResponse(msg.username, msg.text, msg.platform);
+                                    : cmdResult
+                                        ? Promise.resolve(cmdResult)
+                                        : weatherResult
+                                            ? Promise.resolve(weatherResult)
+                                            : chatAI
+                                                ? chatAI.processMessage(msg.username, msg.text, msg.platform).then(r => r || generateResponse(msg.username, msg.text, msg.platform))
+                                                : generateResponse(msg.username, msg.text, msg.platform);
                     responsePromise.then(response => {
                         queueSpeech(`@${msg.username}: ${response}`, 'talking', 80, 48, 'chat-response');
                         memory.totalResponses++;
@@ -3451,23 +4017,26 @@ function startStream(platforms) {
         const tee = platforms.map(p => `[f=flv]${p.endpoint}/${p.key}`).join('|');
         outputArgs = ['-f', 'tee', tee];
     }
+    const usePCMAudio = audioEngine?.pcmEnabled ?? false;
     const ffmpegArgs = [
         '-f', 'rawvideo', '-pix_fmt', 'rgb24',
         '-s', `${WIDTH}x${HEIGHT}`, '-r', String(FPS),
         '-i', 'pipe:0',
-        '-f', 'lavfi', '-i', 'anullsrc=r=44100:cl=stereo',
-        '-c:v', 'libx264', '-preset', 'veryfast',
-        '-b:v', '2000k', '-maxrate', '2000k', '-bufsize', '4000k',
-        '-g', String(FPS * 2), '-keyint_min', String(FPS * 2),
-        '-pix_fmt', 'yuv420p',
-        '-c:a', 'aac', '-b:a', '128k', '-ar', '44100',
-        '-shortest',
     ];
+    // If PCM audio, use pipe:3. Otherwise use anullsrc.
+    if (usePCMAudio) {
+        ffmpegArgs.push('-f', 'f32le', '-ar', '44100', '-ac', '1', '-i', 'pipe:3');
+    }
+    else {
+        ffmpegArgs.push('-f', 'lavfi', '-i', 'anullsrc=r=44100:cl=stereo');
+    }
+    ffmpegArgs.push('-c:v', 'libx264', '-preset', 'veryfast', '-b:v', '2000k', '-maxrate', '2000k', '-bufsize', '4000k', '-g', String(FPS * 2), '-keyint_min', String(FPS * 2), '-pix_fmt', 'yuv420p', '-c:a', 'aac', '-b:a', '128k', '-ar', '44100', '-shortest');
     if (platforms.length > 1) {
         ffmpegArgs.push('-map', '0:v', '-map', '1:a');
     }
     ffmpegArgs.push(...outputArgs);
-    const proc = spawn('ffmpeg', ffmpegArgs, { stdio: ['pipe', 'pipe', 'pipe'] });
+    const stdioConfig = usePCMAudio ? ['pipe', 'pipe', 'pipe', 'pipe'] : ['pipe', 'pipe', 'pipe'];
+    const proc = spawn('ffmpeg', ffmpegArgs, { stdio: stdioConfig });
     frameTimer = setInterval(() => {
         if (!proc.stdin || proc.stdin.destroyed)
             return;
@@ -3477,6 +4046,16 @@ function startStream(platforms) {
             charState.frameCount++;
         }
         catch { }
+        // Write real PCM audio samples to pipe:3 when available
+        if (usePCMAudio && audioEngine && audioEngine.pcmEnabled && proc.stdio[3] && !proc.stdio[3].destroyed) {
+            const samplesPerFrame = Math.floor(44100 / FPS); // ~7350 samples per frame at 6fps
+            const audioBuf = generateAudioBuffer(audioEngine, samplesPerFrame, 44100);
+            const buffer = Buffer.from(audioBuf.buffer, audioBuf.byteOffset, audioBuf.byteLength);
+            try {
+                proc.stdio[3].write(buffer);
+            }
+            catch { }
+        }
     }, 1000 / FPS);
     return proc;
 }
@@ -3548,8 +4127,19 @@ export function registerStreamRendererTools() {
             evolutionEngine = loadEvolutionState() || initEvolutionEngine();
             narrativeEngine = loadNarrative() || createNarrativeEngine();
             audioEngine = createAudioEngine();
+            audioEngine.pcmEnabled = true;
+            audioEngine.musicEnabled = true;
             socialEngine = loadSocialEngine();
             activeAudioDescription = null;
+            // Init new systems (v2)
+            overlay = getOverlay();
+            weatherSystem = getWeatherSystem();
+            chatAI = new StreamChatAI();
+            chatAI.loadMemory();
+            vodSystem = new StreamVOD();
+            vodSystem.loadState();
+            streamCommands = getStreamCommands();
+            streamCommands.loadState();
             agenda = {
                 currentIndex: 0,
                 currentSegment: 'welcome',
@@ -3602,6 +4192,15 @@ export function registerStreamRendererTools() {
                 saveNarrative(narrativeEngine);
             if (socialEngine)
                 saveSocialEngine(socialEngine);
+            // Save new systems
+            if (chatAI)
+                chatAI.saveMemory();
+            if (vodSystem && vodSystem.isRecording())
+                vodSystem.stopRecording();
+            if (vodSystem)
+                vodSystem.saveState();
+            if (streamCommands)
+                streamCommands.saveState();
             const elapsed = Math.floor((Date.now() - charState.startTime) / 60000);
             return `Stream stopped after ${elapsed}m.\nFrames: ${charState.frameCount}\nMessages: ${memory.totalMessages}\nUsers learned: ${Object.keys(memory.users).length}\nFacts: ${memory.sessionFacts.length}\nSegments completed: ${agenda.currentIndex}`;
         },