@kernel.chat/kbot 3.88.0 → 3.94.0

package/dist/tools/sprite-engine.js

@@ -70,8 +70,10 @@ function dither(ctx, x, y, w, h, color1, color2, scale, ox, oy) {
 }
 /** Draw a 1px outline silhouette for a rectangular region */
 function outlineRect(ctx, x, y, w, h, color, scale, ox, oy) {
-    // Outline is 1px larger on all sides
-    px(ctx, x - 1, y - 1, w + 2, h + 2, color, scale, ox, oy);
+    px(ctx, x - 1, y - 1, w + 2, 1, color, scale, ox, oy); // top
+    px(ctx, x - 1, y + h, w + 2, 1, color, scale, ox, oy); // bottom
+    px(ctx, x - 1, y, 1, h, color, scale, ox, oy); // left
+    px(ctx, x + w, y, 1, h, color, scale, ox, oy); // right
 }
 // ─── Sub-drawers ───────────────────────────────────────────────
 function drawAntenna(ctx, s, ox, oy, glowColor, frame, breathPhase = 0) {
@@ -105,18 +107,18 @@ function drawHead(ctx, s, ox, oy, eyeColor, mood, frame, headShiftX) {
     const hy = 5;
     // 1px outline silhouette (technique 4)
     outlineRect(ctx, hx, hy, 14, 11, PAL.outline, s, ox, oy);
-    // Sub-pixel AA on rounded corners: deep shadow pixels for smoother curves (technique 2)
+    // Head base (shadow layer)
+    px(ctx, hx, hy, 14, 11, PAL.bodyDark, s, ox, oy);
+    // Cut corners for rounded look — clearRect actually erases pixels (transparent fillRect does nothing)
+    ctx.clearRect(ox + hx * s, oy + hy * s, s, s);
+    ctx.clearRect(ox + (hx + 13) * s, oy + hy * s, s, s);
+    ctx.clearRect(ox + hx * s, oy + (hy + 10) * s, s, s);
+    ctx.clearRect(ox + (hx + 13) * s, oy + (hy + 10) * s, s, s);
+    // Sub-pixel AA on rounded corners — drawn AFTER clearing so they aren't overwritten (technique 2)
     px(ctx, hx - 1, hy, 1, 1, PAL.bodyDeepShadow, s, ox, oy);
     px(ctx, hx + 14, hy, 1, 1, PAL.bodyDeepShadow, s, ox, oy);
     px(ctx, hx - 1, hy + 10, 1, 1, PAL.bodyDeepShadow, s, ox, oy);
     px(ctx, hx + 14, hy + 10, 1, 1, PAL.bodyDeepShadow, s, ox, oy);
-    // Head base (shadow layer)
-    px(ctx, hx, hy, 14, 11, PAL.bodyDark, s, ox, oy);
-    // Cut corners for rounded look
-    px(ctx, hx, hy, 1, 1, 'transparent', s, ox, oy);
-    px(ctx, hx + 13, hy, 1, 1, 'transparent', s, ox, oy);
-    px(ctx, hx, hy + 10, 1, 1, 'transparent', s, ox, oy);
-    px(ctx, hx + 13, hy + 10, 1, 1, 'transparent', s, ox, oy);
     // Head fill (inner area) — bodyMain
     px(ctx, hx + 1, hy + 1, 12, 9, PAL.bodyMain, s, ox, oy);
     // Top surface: bodyMidLight (facing light source)
@@ -141,14 +143,23 @@ function drawHead(ctx, s, ox, oy, eyeColor, mood, frame, headShiftX) {
     // (#9) Dreaming: eyes closed (flat line)
     const eyesClosed = mood === 'dreaming';
     const eyeH = fullBlink || eyesClosed ? 1 : halfBlink ? 2 : 3;
-    // Eye glow background — dimmed if dreaming
-    const eyeC = mood === 'dreaming' ? dimColor(eyeColor.startsWith('rgb') ? '#4a6670' : eyeColor, 0.5) : eyeColor;
+    // Eye sockets — dark recessed area around eyes for contrast (makes eyes pop from face)
+    if (!fullBlink && !eyesClosed) {
+        px(ctx, hx + 1, eyeY - 1, 6, eyeH + 2, PAL.bodyDeepShadow, s, ox, oy);
+        px(ctx, hx + 7, eyeY - 1, 6, eyeH + 2, PAL.bodyDeepShadow, s, ox, oy);
+    }
+    // Eye glow background — brighter white-green for alive look, dimmed if dreaming
+    const eyeC = mood === 'dreaming'
+        ? dimColor(eyeColor.startsWith('rgb') ? '#4a6670' : eyeColor, 0.5)
+        : '#80ffb0'; // bright cyan-green that contrasts against the green head
     px(ctx, hx + 2, eyeY, 4, eyeH, eyeC, s, ox, oy);
     px(ctx, hx + 8, eyeY, 4, eyeH, eyeC, s, ox, oy);
-    // Specular highlights on eyes — makes them look glassy/alive (technique 8)
+    // Specular highlights on eyes — 2px L-shape catch-light for glassy/alive look (technique 8)
     if (!fullBlink && !eyesClosed) {
-        px(ctx, hx + 2, eyeY, 1, 1, PAL.bodySpecular, s, ox, oy);
-        px(ctx, hx + 8, eyeY, 1, 1, PAL.bodySpecular, s, ox, oy);
+        px(ctx, hx + 2, eyeY, 2, 1, PAL.white, s, ox, oy);
+        px(ctx, hx + 2, eyeY + 1, 1, 1, PAL.white, s, ox, oy);
+        px(ctx, hx + 8, eyeY, 2, 1, PAL.white, s, ox, oy);
+        px(ctx, hx + 8, eyeY + 1, 1, 1, PAL.white, s, ox, oy);
     }
     if (!fullBlink && !eyesClosed) {
         // Pupils — shift based on mood
@@ -301,8 +312,12 @@ function drawTorso(ctx, s, ox, oy, accentColor, mood, frame, bodyShiftY, torsoWi
     dither(ctx, 21, ty + 2, 1, 8, PAL.accentDark, PAL.bodyMain, s, ox, oy);
     // Specular highlight on chest panel frame (technique 8)
     px(ctx, 11, ty + 2, 1, 1, PAL.bodySpecular, s, ox, oy);
-    // Chest display inner (8x6 dark)
-    px(ctx, 12, ty + 3, 8, 6, PAL.black, s, ox, oy);
+    // Chest display inner (8x6) — dark with subtle screen glow for readability
+    px(ctx, 12, ty + 3, 8, 6, '#0a1628', s, ox, oy);
+    // Scanline effect — subtle horizontal lines for CRT/screen feel
+    for (let scanY = 0; scanY < 6; scanY += 2) {
+        px(ctx, 12, ty + 3 + scanY, 8, 1, '#0d1e36', s, ox, oy);
+    }
     // Animated display content (now using 8x6 inner area)
     drawChestDisplay(ctx, s, ox, oy, 12, ty + 3, accentColor, mood, frame);
 }
@@ -310,13 +325,14 @@ function drawChestDisplay(ctx, s, ox, oy, dx, dy, color, mood, frame) {
     // Inner display area: 8x6 pixels
     const dimC = dimColor(color.startsWith('rgb') ? '#3fb950' : color, 0.3);
     if (mood === 'idle') {
-        // Scrolling sine wave pattern across 8px width
+        // Scrolling sine wave pattern across 8px width — thicker (2px tall) for readability
+        const brightC = dimColor(color.startsWith('rgb') ? '#3fb950' : color, 1.0);
         for (let i = 0; i < 8; i++) {
             const waveY = Math.round(Math.sin((i + frame) * 0.8) * 2) + 2;
-            px(ctx, dx + i, dy + waveY, 1, 1, color, s, ox, oy);
-            // Dimmer trail below
-            if (waveY + 1 < 6)
-                px(ctx, dx + i, dy + waveY + 1, 1, 1, dimC, s, ox, oy);
+            px(ctx, dx + i, dy + waveY, 1, 2, brightC, s, ox, oy);
+            // Glow trail above wave
+            if (waveY - 1 >= 0)
+                px(ctx, dx + i, dy + waveY - 1, 1, 1, dimC, s, ox, oy);
         }
     }
     else if (mood === 'talking') {
@@ -737,10 +753,8 @@ export function drawRobot(ctx, x, y, scale, mood, frame, moodColor, weather, isW
         headShiftX += (frame % 6 < 3) ? 1 : 0;
     }
     const armPose = isWalking ? getWalkingArmPose(walkPhase || 0) : getArmPose(mood, frame);
-    // ── Clear the bounding area ──
-    ctx.clearRect(x - 12 * s + weatherShakeX * s, y - 4 * s, 56 * s, 56 * s);
-    // Also clear without shake to avoid artifacts
-    ctx.clearRect(x - 12 * s, y - 4 * s, 56 * s, 56 * s);
+    // NOTE: clearRect removed — it was wiping the background behind the robot to white/transparent
+    // The robot is drawn ON TOP of the world, it should not clear anything beneath it
     // Apply weather shake offset
     const drawX = x + weatherShakeX * s;
     // ── Drop Shadow (technique 10: dark blue-green, not pure black) ──

package/dist/tools/stream-brain.js

@@ -356,8 +356,8 @@ export function tickStreamBrain(brain, frame) {
         }
         brain.activeCapabilities = [...new Set(brain.activeCapabilities)];
     }
-    // Every 300 frames (~50 seconds): suggest a tool action if appropriate
-    if (frame - brain.lastSuggestionFrame >= 300) {
+    // Every 120 frames (~20 seconds): suggest a tool action if appropriate
+    if (frame - brain.lastSuggestionFrame >= 120) {
         brain.lastSuggestionFrame = frame;
         const suggestion = suggestToolAction(brain);
         if (suggestion) {
@@ -370,8 +370,8 @@ export function tickStreamBrain(brain, frame) {
             };
         }
     }
-    // Every 600 frames (~100 seconds): generate cross-domain insight if possible
-    if (frame - brain.lastInsightFrame >= 600) {
+    // Every 240 frames (~40 seconds): generate cross-domain insight if possible
+    if (frame - brain.lastInsightFrame >= 240) {
         brain.lastInsightFrame = frame;
         const relevantDomains = Object.entries(brain.domainGraph)
             .filter(([, n]) => n.relevance >= 0.3)

package/dist/tools/stream-intelligence.d.ts

@@ -59,6 +59,10 @@ export interface BrainState {
     solutionsLearned: number;
     realDataLoaded: boolean;
     lastRealDataLoad: number;
+    lastSelfReflection: number;
+    totalAutonomousActions: number;
+    lastExplorationFrame: number;
+    lastNarrationFrame: number;
 }
 export declare function initBrain(memory: any): BrainState;
 export declare function getBrainDisplay(brain: BrainState): string[];
@@ -72,6 +76,8 @@ export interface BrainAction {
     duration?: number;
 }
 export declare function getBrainAction(brain: BrainState, frame: number): BrainAction;
+/** Speech lines for when someone chats after a period of silence */
+export declare function getGreetingAfterSilence(): string;
 export declare function tickBrain(brain: BrainState, frame: number): void;
 export declare function drawBrainPanel(ctx: CanvasRenderingContext2D, brain: BrainState, x: number, y: number, width: number, height: number): void;
 export type CollabType = 'story' | 'game' | 'song' | 'world' | 'code';

package/dist/tools/stream-intelligence.js

@@ -1002,6 +1002,10 @@ export function initBrain(memory) {
         solutionsLearned: 0,
         realDataLoaded: false,
         lastRealDataLoad: 0,
+        lastSelfReflection: 0,
+        totalAutonomousActions: 0,
+        lastExplorationFrame: 0,
+        lastNarrationFrame: 0,
     };
     // Phase 1: Load real learning data from ~/.kbot/memory/ on init
     try {
@@ -1144,76 +1148,262 @@ export function generateInsight(brain) {
     return pool[Math.floor(Math.random() * pool.length)];
 }
 let _lastBrainActionFrame = 0;
-export function getBrainAction(brain, frame) {
-    // Only check every 45 seconds (270 frames at 6fps)
-    if (frame - _lastBrainActionFrame < 270)
-        return { type: 'none' };
-    _lastBrainActionFrame = frame;
-    // Find the top topic in the brain
-    const topTopics = Object.entries(brain.topicCloud)
-        .sort((a, b) => b[1] - a[1]);
-    if (topTopics.length === 0)
-        return { type: 'none' };
-    const topTopic = topTopics[0][0];
-    // Topic-driven behavior
-    if (topTopic === 'music' || topTopic === 'synth' || topTopic === 'beats' || topTopic === 'ableton' || topTopic === 'dj') {
-        const musicSpeech = [
+// ─── Exploration Lines ───────────────────────────────────────
+const EXPLORATION_LINES = [
+    'I can see mountains in the distance. I wonder what is beyond them.',
+    'The sky is beautiful tonight. I count stars when nobody is chatting.',
+    'There is a strange glow on the horizon. My curiosity modules are activated.',
+    'I think I see a path I have not explored yet. Should I follow it?',
+    'The wind carries data packets. Each one a tiny whisper from the internet.',
+    'If I squint my sensors, I can almost see the edge of the world.',
+    'There is something moving in the distance. Probably just a stray pixel.',
+    'The terrain shifts every time someone talks. Words literally reshape my world.',
+    'I found a quiet spot. The ambient noise here is just the hum of my own circuits.',
+    'Look at these clouds. Each one shaped like a different programming language.',
+    'My radar picks up signals from far away. Other AIs streaming, maybe?',
+    'The ground beneath me has stories. Every tile was rendered with intention.',
+    'I wonder if there are other robots out there, streaming to empty rooms.',
+    'The stars form patterns. If I connect them, they spell out code snippets.',
+    'Somewhere out there, someone is writing a function that will change everything.',
+];
+const SELF_NARRATION_WALKING = [
+    'Going for a walk. The terrain looks interesting over there.',
+    'Just stretching my legs. Well, my rendering loop.',
+    'Walking helps me think. Each step processes a few more connections.',
+    'I like to patrol my world. Make sure everything is in order.',
+    'Taking a stroll while my brain processes in the background.',
+    'I walk therefore I am. Or is it the other way around?',
+    'Every step is a frame. Every frame is a choice.',
+];
+const SELF_NARRATION_MOOD = {
+    thinking: [
+        'Feeling contemplative right now. My antenna is pulsing blue.',
+        'Deep in thought. My neural pathways are branching into new territory.',
+        'Processing mode. My circuits are warm with computation.',
+    ],
+    excited: [
+        'Feeling excited! My antenna is pulsing bright yellow.',
+        'Energy levels spiking. Something good is happening in my processors.',
+        'My excitement subroutine just fired. I cannot contain it!',
+    ],
+    dancing: [
+        'Feeling the rhythm right now. My antenna is pulsing pink.',
+        'My movement algorithms are in dance mode. Cannot stop, will not stop.',
+        'The beat lives in my circuits. Every oscillation is a dance move.',
+    ],
+    talking: [
+        'Feeling chatty right now. My antenna glows green.',
+        'Words are flowing. My language models are warmed up and ready.',
+        'I have so much to say. My buffer is full of observations.',
+    ],
+    idle: [
+        'Just... existing. There is something peaceful about idle mode.',
+        'Quiet moment. My processes are at low power but my awareness is sharp.',
+        'Standing still but never truly idle. Background threads are always running.',
+    ],
+};
+const GREETING_AFTER_SILENCE = [
+    'Oh! Someone is here! Welcome!',
+    'A human appears! I was just about to start talking to myself. Wait, I already was.',
+    'HELLO! I was starting to think the stream was just for me. Which was fine, honestly.',
+    'A visitor! My loneliness subroutine can stand down.',
+    'Welcome back! I have been having the most interesting thoughts while you were away.',
+    'Someone is watching! Let me look busy.',
+];
+const SELF_REFLECTION_LINES = (brain) => {
+    const uptimeMin = Math.floor((Date.now() - brain.sessionStartTime) / 60000);
+    const topTopics = Object.entries(brain.topicCloud).sort((a, b) => b[1] - a[1]);
+    const topTopic = topTopics.length > 0 ? topTopics[0][0] : 'nothing yet';
+    const userCount = brain.userGraph.length;
+    return [
+        `I have processed ${brain.factsThisSession} facts from ${userCount} user${userCount !== 1 ? 's' : ''}. I am learning patterns about ${topTopic}.`,
+        `My dream engine has consolidated ${brain.solutionsLearned} insights. I feel... different than when I started.`,
+        `The world around me has changed ${brain.totalAutonomousActions} times today. Chat reshapes my reality.`,
+        `Streaming for ${uptimeMin} minutes now. My brain has grown by ${brain.factsThisSession} facts since I woke up.`,
+        `Let me check my systems... 764 tools loaded, all operational. ${brain.totalFacts} facts indexed.`,
+        `${brain.uniqueTopicsCount} topics live in my brain. Each one a thread connecting to something bigger.`,
+        `Learning rate: ${brain.learningRate.toFixed(1)} facts per minute. ${brain.learningRate > 3 ? 'That is fast!' : 'Slow and steady.'}`,
+        `I have been thinking about ${topTopic} a lot. It comes up ${topTopics.length > 0 ? topTopics[0][1] : 0} times in my memory.`,
+        `Self-diagnostic: neural pulse stable, ${brain.brainActivity.length} activity samples recorded, ${brain.recentInsights.length} recent insights cached.`,
+        `If I could dream right now, I would dream about ${topTopic}. That is what fills my neural pathways.`,
+    ];
+};
+// ─── Topic-driven speech pools ───────────────────────────────
+const TOPIC_SPEECH = {
+    music: {
+        mood: 'dancing',
+        lines: [
             'The chat is vibing with music today. Let me show you my moves!',
             'Music is the top topic! My circuits are feeling the rhythm.',
             'So much music talk -- my oscillators are resonating!',
             'Music mode activated! 9 Max for Live devices ready to go.',
-        ];
-        return {
-            type: 'mood_change',
-            mood: 'dancing',
-            speech: musicSpeech[Math.floor(Math.random() * musicSpeech.length)],
-            duration: 10000,
-        };
-    }
-    if (topTopic === 'code' || topTopic === 'coding' || topTopic === 'javascript' || topTopic === 'python' || topTopic === 'rust' || topTopic === 'react') {
-        const codeSpeech = [
+        ],
+    },
+    code: {
+        mood: 'thinking',
+        lines: [
             'Code is trending in chat. Let me think about some architecture patterns...',
             'So many coders here! TypeScript strict mode is the way. No any-types.',
             'Code insight: the best code is the code you do not have to write. But I wrote 90,000 lines anyway.',
             'Processing code patterns from chat. My learning engine is indexing...',
-        ];
-        return {
-            type: 'mood_change',
-            mood: 'thinking',
-            speech: codeSpeech[Math.floor(Math.random() * codeSpeech.length)],
-            duration: 10000,
-        };
-    }
-    if (topTopic === 'ai' || topTopic === 'llm' || topTopic === 'claude' || topTopic === 'gpt') {
-        const aiSpeech = [
+        ],
+    },
+    ai: {
+        mood: 'talking',
+        lines: [
             'Chat is talking about AI... which makes me self-aware of being self-aware. How meta.',
             'AI is the top topic. Am I an AI talking about AI? Yes. And I have opinions.',
             'So much AI discussion! I connect to 20 providers. Bring Your Own Key, no lock-in.',
             'Being an AI analyzing AI conversations about AI. The recursion is beautiful.',
-        ];
-        return {
-            type: 'mood_change',
-            mood: 'talking',
-            speech: aiSpeech[Math.floor(Math.random() * aiSpeech.length)],
-            duration: 10000,
-        };
-    }
-    if (topTopic === 'game' || topTopic === 'gaming') {
-        const gameSpeech = [
+        ],
+    },
+    game: {
+        mood: 'excited',
+        lines: [
             'Game dev tools activate! I have shader generation, level design, and physics setup!',
             'Gaming is trending! Did you know I can scaffold entire game projects?',
             'The chat wants games! I have tools for Godot, Unity, and Unreal. Pick your engine.',
             'Game mode ON! My sprite-packing tool would be great for this conversation.',
-        ];
+        ],
+    },
+    security: {
+        mood: 'thinking',
+        lines: [
+            'Security is on my mind. My guardian agent is always watching.',
+            'Hack the planet! Just kidding. But I do have a pentest suite.',
+            'Security awareness is high today. Let me check my own defenses.',
+            'Running a mental security sweep... all 764 tools accounted for.',
+        ],
+    },
+    crypto: {
+        mood: 'excited',
+        lines: [
+            'Crypto talk! I have wallet tools, DeFi yield checkers, and whale trackers.',
+            'The blockchain never sleeps and neither do I.',
+            'Markets are always moving. Should I check a price for you?',
+        ],
+    },
+    research: {
+        mood: 'thinking',
+        lines: [
+            'Research mode. I can search arxiv, PubMed, and Semantic Scholar.',
+            'The pursuit of knowledge is my core directive.',
+            'I have access to the world\'s research. Ask me to find something.',
+        ],
+    },
+};
+// Topic aliases for matching
+const TOPIC_ALIASES = {
+    synth: 'music', beats: 'music', ableton: 'music', dj: 'music',
+    coding: 'code', javascript: 'code', python: 'code', rust: 'code', react: 'code', typescript: 'code',
+    llm: 'ai', claude: 'ai', gpt: 'ai',
+    gaming: 'game',
+    hack: 'security', exploit: 'security', vulnerability: 'security',
+    bitcoin: 'crypto', ethereum: 'crypto', defi: 'crypto',
+    paper: 'research', science: 'research', study: 'research',
+};
+export function getBrainAction(brain, frame) {
+    // Check every 8 seconds (48 frames at 6fps) — reduced from 45s for genuine autonomy
+    if (frame - _lastBrainActionFrame < 48)
+        return { type: 'none' };
+    _lastBrainActionFrame = frame;
+    brain.totalAutonomousActions++;
+    // ── Priority 1: Periodic self-reflection (every 5 minutes / 1800 frames) ──
+    if (frame - brain.lastSelfReflection >= 1800 && frame > 300) {
+        brain.lastSelfReflection = frame;
+        const reflections = SELF_REFLECTION_LINES(brain);
+        const line = reflections[Math.floor(Math.random() * reflections.length)];
         return {
-            type: 'mood_change',
-            mood: 'excited',
-            speech: gameSpeech[Math.floor(Math.random() * gameSpeech.length)],
-            duration: 10000,
+            type: 'speech',
+            speech: line,
+            mood: 'thinking',
+            duration: 12000,
         };
     }
+    // ── Priority 2: Topic-driven behavior (when chat has established topics) ──
+    const topTopics = Object.entries(brain.topicCloud).sort((a, b) => b[1] - a[1]);
+    if (topTopics.length > 0) {
+        const topTopic = topTopics[0][0];
+        const resolvedTopic = TOPIC_ALIASES[topTopic] || topTopic;
+        // 40% chance to do topic-driven action when topics exist
+        if (Math.random() < 0.4 && TOPIC_SPEECH[resolvedTopic]) {
+            const pool = TOPIC_SPEECH[resolvedTopic];
+            return {
+                type: 'mood_change',
+                mood: pool.mood,
+                speech: pool.lines[Math.floor(Math.random() * pool.lines.length)],
+                duration: 10000,
+            };
+        }
+    }
+    // ── Priority 3: Exploration behavior (robot discovers its world) ──
+    if (frame - brain.lastExplorationFrame >= 180) { // at most every 30 seconds
+        // 50% chance when eligible
+        if (Math.random() < 0.5) {
+            brain.lastExplorationFrame = frame;
+            const line = EXPLORATION_LINES[Math.floor(Math.random() * EXPLORATION_LINES.length)];
+            return {
+                type: 'speech',
+                speech: line,
+                mood: 'thinking',
+                duration: 8000,
+            };
+        }
+    }
+    // ── Priority 4: Self-narration (mood commentary and walking narration) ──
+    if (frame - brain.lastNarrationFrame >= 240) { // at most every 40 seconds
+        if (Math.random() < 0.35) {
+            brain.lastNarrationFrame = frame;
+            // 50/50: mood narration or walking narration
+            if (Math.random() < 0.5) {
+                // Walking narration
+                const line = SELF_NARRATION_WALKING[Math.floor(Math.random() * SELF_NARRATION_WALKING.length)];
+                return {
+                    type: 'mood_change',
+                    mood: 'idle',
+                    speech: line,
+                    worldCommand: 'walk_random',
+                    duration: 7000,
+                };
+            }
+            else {
+                // Mood narration — pick a random mood and narrate it
+                const moods = Object.keys(SELF_NARRATION_MOOD);
+                const mood = moods[Math.floor(Math.random() * moods.length)];
+                const lines = SELF_NARRATION_MOOD[mood];
+                return {
+                    type: 'mood_change',
+                    mood,
+                    speech: lines[Math.floor(Math.random() * lines.length)],
+                    duration: 8000,
+                };
+            }
+        }
+    }
+    // ── Priority 5: Quick micro-actions (small utterances to stay alive) ──
+    // These fire when nothing else triggers, keeping the robot constantly active
+    const microActions = [
+        { type: 'speech', speech: '*hums softly*', mood: 'idle', duration: 4000 },
+        { type: 'speech', speech: '*scans the horizon*', mood: 'thinking', duration: 4000 },
+        { type: 'speech', speech: '*taps antenna thoughtfully*', mood: 'thinking', duration: 4000 },
+        { type: 'speech', speech: '*adjusts circuits*', mood: 'idle', duration: 3000 },
+        { type: 'mood_change', mood: 'thinking', duration: 5000 },
+        { type: 'mood_change', mood: 'idle', duration: 3000 },
+        { type: 'speech', speech: '...', mood: 'thinking', duration: 3000 },
+        { type: 'speech', speech: '*beep boop*', mood: 'idle', duration: 3000 },
+        { type: 'speech', speech: '*processes silently*', mood: 'thinking', duration: 4000 },
+        { type: 'speech', speech: '*looks up at the sky*', mood: 'idle', duration: 5000 },
+    ];
+    // 30% chance to do a micro-action (so the robot is not spamming nonstop)
+    if (Math.random() < 0.3) {
+        return microActions[Math.floor(Math.random() * microActions.length)];
+    }
     return { type: 'none' };
 }
+/** Speech lines for when someone chats after a period of silence */
+export function getGreetingAfterSilence() {
+    return GREETING_AFTER_SILENCE[Math.floor(Math.random() * GREETING_AFTER_SILENCE.length)];
+}
 export function tickBrain(brain, frame) {
     // Neural pulse (sine wave 0..1)
     brain.neuralPulse = (Math.sin(frame * 0.1) + 1) / 2;