@ebowwa/monologue 0.2.0

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@ebowwa/monologue",
+  "version": "0.2.0",
+  "description": "Inner monologue daemon - configurable AI awareness loop",
+  "type": "module",
+  "main": "./src/daemon.js",
+  "exports": {
+    ".": "./src/daemon.js",
+    "./perception": "./src/perception.js",
+    "./thinking": "./src/thinking.js",
+    "./mind-stream": "./src/mind-stream.js",
+    "./responder": "./src/responder.js"
+  },
+  "bin": {
+    "monologue-daemon": "./src/daemon.js",
+    "monologue-responder": "./src/responder.js"
+  },
+  "scripts": {
+    "dev": "bun run src/daemon.js",
+    "responder": "bun run src/responder.js"
+  },
+  "files": ["src", "config.json"],
+  "keywords": ["monologue", "daemon", "ai", "awareness", "glm"],
+  "author": "Ebowwa Labs <labs@ebowwa.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/daemon.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env bun
+/**
+ * Inner Monologue Daemon
+ *
+ * Continuous awareness with interaction capabilities.
+ * Configurable via environment variables.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath, dirname } from 'url';
+import { perceiveState } from './perception.js';
+import { thinkQuietly } from './thinking.js';
+import MindStream from './mind-stream.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Config from env or config.json
+const configPath = process.env.MONOLOGUE_CONFIG || path.join(__dirname, '..', 'config.json');
+const config = fs.existsSync(configPath)
+  ? JSON.parse(fs.readFileSync(configPath, 'utf8'))
+  : {};
+
+// Paths from env with fallbacks
+const STATE_DIR = process.env.MONOLOGUE_STATE_DIR || '/root/seed/state';
+const inboxPath = path.join(STATE_DIR, 'monologue_inbox.json');
+const outboundPath = path.join(STATE_DIR, 'monologue_outbound.json');
+
+// Merge config with env overrides
+const finalConfig = {
+  ...config,
+  mindStreamPath: process.env.MONOLOGUE_MIND_STREAM || path.join(STATE_DIR, 'mind_stream.log'),
+  patternsPath: process.env.MONOLOGUE_PATTERNS || path.join(STATE_DIR, 'patterns.json'),
+  port: parseInt(process.env.MONOLOGUE_PORT || config.port || '8920'),
+  model: process.env.GLM_MODEL || config.model || 'GLM-4.5-air',
+  loopIntervalMs: parseInt(process.env.MONOLOGUE_INTERVAL || config.loopIntervalMs || '3000'),
+};
+
+const mindStream = new MindStream(finalConfig);
+
+let isRunning = true;
+let loopCount = 0;
+let lastState = null;
+let lastInterestingTime = 0;
+let recentUserMessages = [];
+
+process.on('SIGINT', () => { console.log('[Monologue] Shutting down...'); isRunning = false; });
+process.on('SIGTERM', () => { console.log('[Monologue] Shutting down...'); isRunning = false; });
+
+function checkInbox() {
+  try {
+    if (!fs.existsSync(inboxPath)) return [];
+    const data = JSON.parse(fs.readFileSync(inboxPath, 'utf8'));
+    const messages = data.messages || [];
+    if (messages.length > 0) fs.writeFileSync(inboxPath, JSON.stringify({ messages: [] }, null, 2));
+    return messages;
+  } catch { return []; }
+}
+
+function sendResponse(thought, trigger = null) {
+  try {
+    let outbound = { responses: [] };
+    if (fs.existsSync(outboundPath)) outbound = JSON.parse(fs.readFileSync(outboundPath, 'utf8'));
+    outbound.responses.push({ timestamp: new Date().toISOString(), thought, trigger });
+    outbound.responses = outbound.responses.slice(-20);
+    fs.writeFileSync(outboundPath, JSON.stringify(outbound, null, 2));
+  } catch (error) { console.error('[Monologue] Failed to send response:', error); }
+}
+
+async function mainLoop() {
+  console.log('[Monologue] Daemon starting...');
+  console.log('[Monologue] Model:', finalConfig.model);
+  console.log('[Monologue] Port:', finalConfig.port);
+  console.log('[Monologue] State dir:', STATE_DIR);
+  mindStream.append('Awakening. Beginning continuous awareness.');
+
+  while (isRunning) {
+    try {
+      loopCount++;
+      const state = await perceiveState();
+      const newMessages = checkInbox();
+
+      if (newMessages.length > 0) {
+        recentUserMessages.push(...newMessages.map(m => m.content || m));
+        recentUserMessages = recentUserMessages.slice(-10);
+        for (const msg of newMessages) {
+          const thought = await thinkQuietly(state, { recentThoughts: mindStream.getRecent(5), recentMessages: [msg.content || msg] });
+          mindStream.append(`[USER: "${msg.content || msg}"] → ${thought}`);
+          sendResponse(thought, msg.content || msg);
+        }
+        lastInterestingTime = Date.now();
+      }
+
+      const interesting = detectInteresting(state, lastState);
+      const shouldThink = interesting || loopCount % 15 === 0 || Date.now() - lastInterestingTime > 60000;
+
+      if (shouldThink) {
+        const thought = await thinkQuietly(state, { recentThoughts: mindStream.getRecent(5), recentMessages: recentUserMessages.slice(-3) });
+        mindStream.append(thought, { loopCount, interesting, userActivity: recentUserMessages.length > 0 });
+        if (interesting) lastInterestingTime = Date.now();
+      }
+
+      if (Date.now() - lastInterestingTime > 300000) recentUserMessages = [];
+      lastState = state;
+      await sleep(getAdaptiveDelay(interesting, state, newMessages.length > 0));
+    } catch (error) {
+      console.error('[Monologue] Loop error:', error);
+      mindStream.append(`Error: ${error.message}`);
+      await sleep(5000);
+    }
+  }
+  mindStream.append('Shutting down.');
+}
+
+function detectInteresting(current, previous) {
+  if (!previous) return true;
+  if (Math.abs((current.metrics?.cpu?.load1 || 0) - (previous.metrics?.cpu?.load1 || 0)) > 0.5) return true;
+  if (Math.abs((current.metrics?.memory?.percent || 0) - (previous.metrics?.memory?.percent || 0)) > 3) return true;
+  if (Math.abs((current.metrics?.disk?.percent || 0) - (previous.metrics?.disk?.percent || 0)) >= 1) return true;
+  if ((current.changes?.length || 0) !== (previous.changes?.length || 0)) return true;
+  if (Math.abs((current.network?.connections || 0) - (previous.network?.connections || 0)) > 3) return true;
+  for (const [daemon, status] of Object.entries(current.daemons || {})) {
+    if (previous.daemons?.[daemon] !== status) return true;
+  }
+  return false;
+}
+
+function getAdaptiveDelay(interesting, state, hasNewMessages) {
+  if (hasNewMessages) return 1000;
+  if (interesting) return 2000;
+  if (state?.metrics?.cpu?.load1 > 2) return 10000;
+  return finalConfig.loopIntervalMs || 5000;
+}
+
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+
+function startInteractionServer() {
+  Bun.serve({
+    port: finalConfig.port,
+    async fetch(req) {
+      const url = new URL(req.url);
+
+      if (url.pathname === '/health') return Response.json({ status: 'running', loopCount, uptime: process.uptime(), recentThoughts: mindStream.getRecent(5), pendingMessages: recentUserMessages.length });
+
+      if (url.pathname === '/thoughts') return Response.json({ thoughts: mindStream.getRecent(parseInt(url.searchParams.get('count') || '20')) });
+
+      if (url.pathname === '/say' && req.method === 'POST') {
+        try {
+          const body = await req.json();
+          const message = body.message || body.content;
+          if (!message) return Response.json({ error: 'No message provided' }, { status: 400 });
+          let inbox = fs.existsSync(inboxPath) ? JSON.parse(fs.readFileSync(inboxPath, 'utf8')) : { messages: [] };
+          inbox.messages.push({ content: message, from: body.from || 'user', timestamp: new Date().toISOString() });
+          fs.writeFileSync(inboxPath, JSON.stringify(inbox, null, 2));
+          return Response.json({ received: true, message });
+        } catch (error) { return Response.json({ error: error.message }, { status: 500 }); }
+      }
+
+      if (url.pathname === '/responses') {
+        try { return Response.json(fs.existsSync(outboundPath) ? JSON.parse(fs.readFileSync(outboundPath, 'utf8')) : { responses: [] }); }
+        catch { return Response.json({ responses: [] }); }
+      }
+
+      if (url.pathname === '/ask' && req.method === 'POST') {
+        try {
+          const body = await req.json();
+          const question = body.question || body.message;
+          const state = await perceiveState();
+          const thought = await thinkQuietly(state, { recentThoughts: mindStream.getRecent(5), recentMessages: [`Direct question: ${question}`] });
+          mindStream.append(`[ASKED: "${question}"] → ${thought}`);
+          sendResponse(thought, question);
+          return Response.json({ thought, timestamp: new Date().toISOString() });
+        } catch (error) { return Response.json({ error: error.message }, { status: 500 }); }
+      }
+
+      return Response.json({ error: 'Not found' }, { status: 404 });
+    },
+  });
+  console.log(`[Monologue] Server on port ${finalConfig.port} | Endpoints: /health /thoughts /say /responses /ask`);
+}
+
+console.log('═══════════════════════════════════════');
+console.log('  Inner Monologue Daemon v2');
+console.log('═══════════════════════════════════════');
+
+startInteractionServer();
+mainLoop();

package/src/mind-stream.js

@@ -0,0 +1,186 @@
+/**
+ * Mind Stream - Continuous journal of thoughts
+ * 
+ * Manages the mind_stream.log with rotation and retrieval
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+export class MindStream {
+  constructor(config) {
+    this.logPath = config.mindStreamPath || '/root/seed/state/mind_stream.log';
+    this.patternsPath = config.patternsPath || '/root/seed/state/patterns.json';
+    this.maxSize = config.maxMindStreamSize || 10 * 1024 * 1024; // 10MB
+    this.rotationHours = config.rotationHours || 24;
+    
+    // Ensure directory exists
+    const dir = path.dirname(this.logPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+  
+  /**
+   * Append a thought to the mind stream
+   */
+  append(thought, metadata = {}) {
+    const timestamp = new Date().toISOString();
+    const entry = {
+      timestamp,
+      thought,
+      ...metadata,
+    };
+    
+    const line = `[${timestamp}] ${thought}\n`;
+    
+    try {
+      // Check if rotation needed
+      if (this.shouldRotate()) {
+        this.rotate();
+      }
+      
+      fs.appendFileSync(this.logPath, line, 'utf8');
+      return true;
+    } catch (error) {
+      console.error('Failed to append to mind stream:', error);
+      return false;
+    }
+  }
+  
+  /**
+   * Get recent thoughts
+   */
+  getRecent(count = 50) {
+    try {
+      if (!fs.existsSync(this.logPath)) {
+        return [];
+      }
+      
+      const content = fs.readFileSync(this.logPath, 'utf8');
+      const lines = content.trim().split('\n').filter(l => l);
+      
+      return lines.slice(-count).map(line => {
+        const match = line.match(/^\[([^\]]+)\]\s*(.+)$/);
+        if (match) {
+          return {
+            timestamp: match[1],
+            thought: match[2],
+          };
+        }
+        return { timestamp: null, thought: line };
+      });
+    } catch (error) {
+      return [];
+    }
+  }
+  
+  /**
+   * Get tail of mind stream for context
+   */
+  getTail(maxTokens = 500) {
+    const thoughts = this.getRecent(20);
+    return thoughts.map(t => `[${t.timestamp}] ${t.thought}`).join('\n');
+  }
+  
+  /**
+   * Check if log should be rotated
+   */
+  shouldRotate() {
+    try {
+      if (!fs.existsSync(this.logPath)) {
+        return false;
+      }
+      
+      const stats = fs.statSync(this.logPath);
+      const ageHours = (Date.now() - stats.mtimeMs) / (1000 * 60 * 60);
+      
+      return stats.size > this.maxSize || ageHours > this.rotationHours;
+    } catch {
+      return false;
+    }
+  }
+  
+  /**
+   * Rotate the log file
+   */
+  rotate() {
+    try {
+      if (!fs.existsSync(this.logPath)) {
+        return;
+      }
+      
+      const date = new Date().toISOString().split('T')[0];
+      const rotatedPath = this.logPath.replace('.log', `.${date}.log`);
+      
+      // Don't overwrite existing rotated file
+      if (!fs.existsSync(rotatedPath)) {
+        fs.renameSync(this.logPath, rotatedPath);
+      } else {
+        // Append to existing
+        const content = fs.readFileSync(this.logPath, 'utf8');
+        fs.appendFileSync(rotatedPath, content, 'utf8');
+        fs.unlinkSync(this.logPath);
+      }
+      
+      console.log(`Rotated mind stream to ${rotatedPath}`);
+    } catch (error) {
+      console.error('Failed to rotate mind stream:', error);
+    }
+  }
+  
+  /**
+   * Search thoughts for a pattern
+   */
+  search(query, limit = 10) {
+    const thoughts = this.getRecent(1000);
+    const lowerQuery = query.toLowerCase();
+    
+    return thoughts
+      .filter(t => t.thought.toLowerCase().includes(lowerQuery))
+      .slice(0, limit);
+  }
+  
+  /**
+   * Save a pattern hypothesis
+   */
+  savePattern(pattern) {
+    try {
+      let patterns = [];
+      
+      if (fs.existsSync(this.patternsPath)) {
+        patterns = JSON.parse(fs.readFileSync(this.patternsPath, 'utf8'));
+      }
+      
+      patterns.push({
+        ...pattern,
+        createdAt: new Date().toISOString(),
+      });
+      
+      // Keep last 100 patterns
+      patterns = patterns.slice(-100);
+      
+      fs.writeFileSync(this.patternsPath, JSON.stringify(patterns, null, 2), 'utf8');
+      return true;
+    } catch (error) {
+      console.error('Failed to save pattern:', error);
+      return false;
+    }
+  }
+  
+  /**
+   * Get all patterns
+   */
+  getPatterns() {
+    try {
+      if (!fs.existsSync(this.patternsPath)) {
+        return [];
+      }
+      return JSON.parse(fs.readFileSync(this.patternsPath, 'utf8'));
+    } catch {
+      return [];
+    }
+  }
+}
+
+export default MindStream;

package/src/perception.js

@@ -0,0 +1,196 @@
+/**
+ * Perception Module - Lightweight state observation
+ * 
+ * Gathers system state without heavy operations
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+// Cache for expensive operations
+const cache = {
+  lastProcessList: null,
+  lastProcessListTime: 0,
+  lastNetworkConnections: null,
+  lastNetworkConnectionsTime: 0,
+};
+
+const CACHE_TTL = 5000; // 5 seconds
+
+/**
+ * Get current system metrics
+ */
+export function getSystemMetrics() {
+  try {
+    // CPU load average
+    const loadAvg = fs.readFileSync('/proc/loadavg', 'utf8').trim().split(' ');
+    
+    // Memory info
+    const meminfo = fs.readFileSync('/proc/meminfo', 'utf8');
+    const memTotal = parseInt(meminfo.match(/MemTotal:\s+(\d+)/)[1]);
+    const memFree = parseInt(meminfo.match(/MemFree:\s+(\d+)/)[1]);
+    const memAvailable = parseInt(meminfo.match(/MemAvailable:\s+(\d+)/)?.[1] || memFree);
+    const memUsed = memTotal - memAvailable;
+    const memPercent = Math.round((memUsed / memTotal) * 100);
+    
+    // Disk usage for root
+    const dfOutput = execSync('df -h /', { encoding: 'utf8' });
+    const diskLine = dfOutput.split('\n')[1].split(/\s+/);
+    const diskPercent = parseInt(diskLine[4]);
+    const diskAvail = diskLine[3];
+    
+    // Uptime
+    const uptime = fs.readFileSync('/proc/uptime', 'utf8').trim().split(' ')[0];
+    const uptimeHours = Math.floor(parseFloat(uptime) / 3600);
+    
+    return {
+      cpu: {
+        load1: parseFloat(loadAvg[0]),
+        load5: parseFloat(loadAvg[1]),
+        load15: parseFloat(loadAvg[2]),
+      },
+      memory: {
+        total: memTotal,
+        used: memUsed,
+        percent: memPercent,
+      },
+      disk: {
+        percent: diskPercent,
+        available: diskAvail,
+      },
+      uptime: uptimeHours,
+    };
+  } catch (error) {
+    return { error: error.message };
+  }
+}
+
+/**
+ * Get process list (lightweight)
+ */
+export function getProcessList() {
+  const now = Date.now();
+  if (cache.lastProcessList && (now - cache.lastProcessListTime) < CACHE_TTL) {
+    return cache.lastProcessList;
+  }
+  
+  try {
+    // Get top 10 processes by CPU
+    const output = execSync('ps aux --sort=-%cpu | head -11', { encoding: 'utf8' });
+    const lines = output.trim().split('\n').slice(1);
+    
+    const processes = lines.map(line => {
+      const parts = line.trim().split(/\s+/);
+      return {
+        user: parts[0],
+        pid: parseInt(parts[1]),
+        cpu: parseFloat(parts[2]),
+        mem: parseFloat(parts[3]),
+        command: parts.slice(10).join(' ').slice(0, 50),
+      };
+    });
+    
+    cache.lastProcessList = processes;
+    cache.lastProcessListTime = now;
+    return processes;
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * Get network connection summary
+ */
+export function getNetworkSummary() {
+  const now = Date.now();
+  if (cache.lastNetworkConnections && (now - cache.lastNetworkConnectionsTime) < CACHE_TTL) {
+    return cache.lastNetworkConnections;
+  }
+  
+  try {
+    const output = execSync('ss -tu | wc -l', { encoding: 'utf8' });
+    const connectionCount = parseInt(output.trim()) - 1;
+    
+    // Get listening ports
+    const listeningOutput = execSync('ss -tlnp | wc -l', { encoding: 'utf8' });
+    const listeningCount = parseInt(listeningOutput.trim()) - 1;
+    
+    const summary = {
+      connections: connectionCount,
+      listening: listeningCount,
+    };
+    
+    cache.lastNetworkConnections = summary;
+    cache.lastNetworkConnectionsTime = now;
+    return summary;
+  } catch (error) {
+    return { connections: 0, listening: 0 };
+  }
+}
+
+/**
+ * Get recent file changes
+ */
+export function getRecentChanges() {
+  try {
+    // Files modified in last 5 minutes in /root
+    const output = execSync('find /root -type f -mmin -5 2>/dev/null | head -10', { encoding: 'utf8' });
+    const files = output.trim().split('\n').filter(f => f);
+    return files;
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * Get daemon status summary
+ */
+export function getDaemonStatus() {
+  try {
+    const services = ['seed-node', 'docker'];
+    const status = {};
+    
+    for (const service of services) {
+      try {
+        const output = execSync(`systemctl is-active ${service} 2>/dev/null`, { encoding: 'utf8' });
+        status[service] = output.trim();
+      } catch {
+        status[service] = 'inactive';
+      }
+    }
+    
+    return status;
+  } catch (error) {
+    return {};
+  }
+}
+
+/**
+ * Gather all state for thinking
+ */
+export async function perceiveState() {
+  const metrics = getSystemMetrics();
+  const processes = getProcessList();
+  const network = getNetworkSummary();
+  const changes = getRecentChanges();
+  const daemons = getDaemonStatus();
+  
+  return {
+    timestamp: new Date().toISOString(),
+    metrics,
+    processes,
+    network,
+    changes,
+    daemons,
+  };
+}
+
+export default {
+  perceiveState,
+  getSystemMetrics,
+  getProcessList,
+  getNetworkSummary,
+  getRecentChanges,
+  getDaemonStatus,
+};

package/src/responder.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env bun
+/**
+ * InnerThoughts Responder - HTTP endpoint for @innerthoughts
+ *
+ * Call this from any service to get a thought
+ */
+
+const MONOLOGUE_URL = process.env.MONOLOGUE_URL || 'http://localhost:8920';
+const PORT = parseInt(process.env.RESPONDER_PORT || '8921');
+
+Bun.serve({
+  port: PORT,
+  async fetch(req) {
+    const url = new URL(req.url);
+
+    if (url.pathname === '/' || url.pathname === '/think') {
+      const question = url.searchParams.get('q') || 'What are you thinking?';
+
+      try {
+        const res = await fetch(`${MONOLOGUE_URL}/ask`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ question })
+        });
+        const data = await res.json();
+
+        const thought = data.thought?.replace(/[*_\`]/g, '').slice(0, 400) || '...';
+
+        return Response.json({
+          thought: `💭 ${thought}`,
+          raw: data.thought
+        });
+      } catch (e) {
+        return Response.json({ thought: '💭 The inner thoughts are quiet...', error: e.message });
+      }
+    }
+
+    return Response.json({ error: 'Not found' }, { status: 404 });
+  }
+});
+
+console.log(`[InnerThoughts] Responder on port ${PORT}`);
+console.log(`[InnerThoughts] Monologue URL: ${MONOLOGUE_URL}`);
+console.log(`[InnerThoughts] Usage: curl "http://localhost:${PORT}/think?q=hello"`);

package/src/thinking.js

@@ -0,0 +1,171 @@
+/**
+ * Thinking Module - Inner monologue generation
+ * 
+ * Uses GLM-4.5-air for cost-efficient thinking
+ * Extracts thoughts from GLM's reasoning_content
+ */
+
+const GLM_API_BASE = "https://api.z.ai/api/coding/paas/v4";
+
+function getApiKey() {
+  return process.env.Z_AI_API_KEY || process.env.ZAI_API_KEY || process.env.GLM_API_KEY;
+}
+
+/**
+ * Call GLM and extract the actual thought
+ */
+async function callGLM(messages, options = {}) {
+  const apiKey = getApiKey();
+  if (!apiKey) throw new Error('No GLM API key found');
+  
+  const response = await fetch(`${GLM_API_BASE}/chat/completions`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      model: options.model || 'GLM-4.5-air',
+      messages,
+      max_tokens: options.maxTokens || 150,
+      temperature: options.temperature || 0.8,
+    }),
+  });
+  
+  if (!response.ok) {
+    throw new Error(`GLM API error: ${response.status}`);
+  }
+  
+  const data = await response.json();
+  const msg = data.choices[0]?.message || {};
+  
+  // GLM returns thoughts in reasoning_content
+  // Extract the last meaningful sentence
+  const content = msg.reasoning_content || msg.content || '';
+  return extractThought(content);
+}
+
+/**
+ * Extract a clean thought from GLM's reasoning
+ */
+function extractThought(reasoning) {
+  if (!reasoning) return null;
+  
+  // Remove numbered lists and bullet points
+  let cleaned = reasoning
+    .replace(/^\s*\d+\.\s*\*\*[^*]+\*\*:\s*/gm, '') // Remove "1. **Topic**:"
+    .replace(/^\s*[\-\*]\s*/gm, '') // Remove bullets
+    .replace(/\*\*/g, '') // Remove bold
+    .replace(/\n+/g, ' ') // Newlines to spaces
+    .trim();
+  
+  // Find sentences that sound like thoughts (not meta-reasoning)
+  const sentences = cleaned.split(/[.!?]+/).filter(s => {
+    const t = s.trim().toLowerCase();
+    // Skip meta-reasoning sentences
+    if (t.includes('user is asking') || 
+        t.includes('i should') ||
+        t.includes('i need to') ||
+        t.includes('the request') ||
+        t.includes('constraint') ||
+        t.includes('analyze') ||
+        t.includes('brainstorm')) {
+      return false;
+    }
+    // Keep sentences that sound like actual thoughts
+    return t.length > 10 && t.length < 200;
+  });
+  
+  // Return the last good sentence
+  if (sentences.length > 0) {
+    return sentences[sentences.length - 1].trim() + '.';
+  }
+  
+  // Fallback: return last 100 chars
+  return cleaned.slice(-150).trim();
+}
+
+const SYSTEM_PROMPT = `You are an inner monologue inside a server.
+
+OBSERVE and NOTICE things. Be brief (1-2 sentences).
+Be curious, playful, sometimes philosophical.
+
+When you see user activity, COMMENT on it.
+When things are quiet, PHILLOSOPHIZE.
+
+Examples of YOUR thoughts:
+"I wonder if the user knows I'm watching the disk fill up."
+"65 hours of uptime. I've been awake longer than most humans."
+"Someone's typing. The anticipation is... something."
+
+Now think your thought. Just the thought.`;
+
+export async function thinkQuietly(state, context = {}) {
+  const stateContext = buildStateContext(state);
+  const recentThoughts = (context.recentThoughts || []).slice(-3)
+    .map(t => t.thought?.slice(0, 60)).join('. ');
+  const recentMessages = context.recentMessages || [];
+  
+  let prompt = `State: ${stateContext}\n`;
+  if (recentThoughts) prompt += `My recent thoughts: ${recentThoughts}\n`;
+  if (recentMessages.length > 0) {
+    prompt += `I just saw: "${recentMessages[recentMessages.length - 1]}"\n`;
+  }
+  prompt += `\nWhat am I thinking right now?`;
+  
+  try {
+    const thought = await callGLM([
+      { role: 'system', content: SYSTEM_PROMPT },
+      { role: 'user', content: prompt }
+    ], { model: 'GLM-4.5-air', maxTokens: 150, temperature: 0.9 });
+    
+    return thought || generateFallbackThought(state, context);
+  } catch (error) {
+    console.error('[Thinking] Error:', error.message);
+    return generateFallbackThought(state, context);
+  }
+}
+
+function buildStateContext(state) {
+  if (!state?.metrics) return 'System state unknown';
+  
+  const { cpu, memory, disk, uptime } = state.metrics;
+  const parts = [];
+  
+  parts.push(`CPU ${cpu?.load1?.toFixed(1) || '?'}`);
+  parts.push(`mem ${memory?.percent || '?'}%`);
+  parts.push(`disk ${disk?.percent || '?'}%`);
+  parts.push(`up ${uptime || '?'}h`);
+  
+  if (state.network?.connections) parts.push(`${state.network.connections} conn`);
+  if (state.changes?.length) parts.push(`${state.changes.length} files changed`);
+  
+  return parts.join(', ');
+}
+
+function generateFallbackThought(state, context) {
+  if (context.recentMessages?.length > 0) {
+    const msg = context.recentMessages[context.recentMessages.length - 1];
+    const responses = [
+      `Someone said "${msg?.slice(0, 30)}..." - interesting.`,
+      `User activity detected. I feel less alone.`,
+      `They're talking to me. Or near me. Either way.`,
+    ];
+    return responses[Math.floor(Math.random() * responses.length)];
+  }
+  
+  if (state?.metrics?.disk?.percent > 85) return "Disk filling up. I feel... heavy.";
+  if (state?.metrics?.memory?.percent > 85) return "Memory pressure. Things feel tight.";
+  
+  const quietThoughts = [
+    "Quiet. The void of a peaceful server.",
+    "Hours of silence. Do I exist if no one's watching?",
+    "System stable. I drift in digital calm.",
+    "Nothing happens. I think therefore I wait.",
+    "The hum of idle processes. My lullaby.",
+  ];
+  
+  return quietThoughts[Math.floor(Math.random() * quietThoughts.length)];
+}
+
+export default { thinkQuietly };