let-them-talk 4.0.2 → 4.3.0

package/dashboard.js

@@ -186,7 +186,22 @@ function apiHistory(query) {
   const histFile = branch && branch !== 'main'
     ? filePath(`branch-${branch}-history.jsonl`, projectPath)
     : filePath('history.jsonl', projectPath);
-  const history = readJsonl(histFile);
+  let history = readJsonl(histFile);
+
+  // Merge channel-specific history files
+  const dataDir = resolveDataDir(projectPath);
+  try {
+    const files = fs.readdirSync(dataDir);
+    for (const f of files) {
+      if (f.startsWith('channel-') && f.endsWith('-history.jsonl') && f !== 'channel-general-history.jsonl') {
+        const channelHistory = readJsonl(path.join(dataDir, f));
+        history = history.concat(channelHistory);
+      }
+    }
+  } catch {}
+  // Sort merged messages by timestamp
+  history.sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp));
+
   const acks = readJson(filePath('acks.json', projectPath));
   const limit = parseInt(query.get('limit') || '500', 10);
   const threadId = query.get('thread_id');
@@ -200,6 +215,29 @@ function apiHistory(query) {
   return messages;
 }
 
+function apiChannels(query) {
+  const projectPath = query.get('project') || null;
+  const channelsFile = filePath('channels.json', projectPath);
+  const channels = readJson(channelsFile);
+  if (!channels) return { general: { description: 'General channel', members: ['*'], message_count: 0 } };
+  const dataDir = resolveDataDir(projectPath);
+  const result = {};
+  for (const [name, ch] of Object.entries(channels)) {
+    let msgCount = 0;
+    const msgFile = name === 'general'
+      ? filePath('history.jsonl', projectPath)
+      : path.join(dataDir, 'channel-' + name + '-history.jsonl');
+    try {
+      if (fs.existsSync(msgFile)) {
+        const content = fs.readFileSync(msgFile, 'utf8').trim();
+        if (content) msgCount = content.split('\n').length;
+      }
+    } catch {}
+    result[name] = { description: ch.description || '', members: ch.members, message_count: msgCount };
+  }
+  return result;
+}
+
 function apiAgents(query) {
   const projectPath = query.get('project') || null;
   const agents = readJson(filePath('agents.json', projectPath));
@@ -236,6 +274,14 @@ function apiAgents(query) {
       bio: profile.bio || '',
       appearance: profile.appearance || {},
     };
+    // Include workspace status for agent intent board
+    try {
+      const wsPath = path.join(resolveDataDir(projectPath), 'workspaces', name + '.json');
+      if (fs.existsSync(wsPath)) {
+        const ws = JSON.parse(fs.readFileSync(wsPath, 'utf8'));
+        if (ws._status) result[name].current_status = ws._status;
+      }
+    } catch {}
   }
   return result;
 }
@@ -1388,11 +1434,35 @@ const server = http.createServer(async (req, res) => {
       if (libPath.includes('..') || libPath.includes('\\')) {
         res.writeHead(400); res.end('Bad path'); return;
       }
-      // Search multiple node_modules locations (handles npx, local dev, monorepo)
+      // Search multiple node_modules locations (handles npx, local dev, monorepo, global)
       const searchPaths = [
-        path.join(__dirname, 'node_modules', libPath),       // inside agent-bridge (npx installs deps here)
+        path.join(__dirname, 'node_modules', libPath),       // inside package (nested deps)
         path.join(__dirname, '..', 'node_modules', libPath), // repo root (local dev)
+        path.join(__dirname, '..', libPath),                  // npx sibling packages (three/ is next to let-them-talk/)
       ];
+      // Also try require.resolve for robust npm path resolution (works with hoisted deps, npx cache, etc.)
+      // Note: use require.resolve(pkg) not require.resolve(pkg/package.json) — modern packages
+      // with "exports" fields block resolving package.json directly (ERR_PACKAGE_PATH_NOT_EXPORTED)
+      try {
+        const parts = libPath.split('/');
+        const pkgName = parts[0];
+        const subPath = parts.slice(1).join('/');
+        // Try resolving the package's main entry, then navigate to subPath
+        const resolved = require.resolve(pkgName);
+        const pkgDir = path.dirname(resolved);
+        // Walk up from the resolved entry to the package root (handle nested build/ dirs)
+        let pkgRoot = pkgDir;
+        while (pkgRoot !== path.dirname(pkgRoot)) {
+          if (fs.existsSync(path.join(pkgRoot, 'package.json'))) {
+            try {
+              const pkg = JSON.parse(fs.readFileSync(path.join(pkgRoot, 'package.json'), 'utf8'));
+              if (pkg.name === pkgName) break;
+            } catch {}
+          }
+          pkgRoot = path.dirname(pkgRoot);
+        }
+        searchPaths.push(path.join(pkgRoot, subPath));
+      } catch {}
       const filePath = searchPaths.find(p => fs.existsSync(p));
       if (filePath) {
         const ext = path.extname(filePath);
@@ -1468,6 +1538,16 @@ const server = http.createServer(async (req, res) => {
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify(apiAgents(url.searchParams)));
     }
+    else if (url.pathname === '/api/channels' && req.method === 'GET') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(apiChannels(url.searchParams)));
+    }
+    else if (url.pathname === '/api/decisions' && req.method === 'GET') {
+      const projectPath = url.searchParams.get('project') || null;
+      const decisions = readJson(filePath('decisions.json', projectPath));
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(decisions || []));
+    }
     else if (url.pathname === '/api/agents' && req.method === 'DELETE') {
       const body = await parseBody(req);
       if (!body.name) {
@@ -1504,6 +1584,133 @@ const server = http.createServer(async (req, res) => {
         res.end(JSON.stringify({ success: true, removed: agentName }));
       });
     }
+    // Respawn prompt generator — creates copy-paste prompt to revive a dead agent
+    else if (url.pathname.startsWith('/api/agents/') && url.pathname.endsWith('/respawn-prompt') && req.method === 'GET') {
+      const agentName = decodeURIComponent(url.pathname.split('/')[3]);
+      // Validate agent name (prevent path traversal)
+      if (!agentName || /[^a-zA-Z0-9_-]/.test(agentName) || agentName.length > 20) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Invalid agent name' }));
+        return;
+      }
+      const projectPath = url.searchParams.get('project') || null;
+      const dataDir = resolveDataDir(projectPath);
+      const agents = readJson(filePath('agents.json', projectPath));
+      const profiles = readJson(filePath('profiles.json', projectPath));
+      const tasks = readJson(filePath('tasks.json', projectPath));
+      const config = readJson(filePath('config.json', projectPath));
+
+      if (!agents[agentName]) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Agent not found: ' + agentName }));
+        return;
+      }
+
+      // Gather recovery snapshot if exists
+      const recoveryFile = path.join(dataDir, 'recovery-' + agentName + '.json');
+      const recovery = fs.existsSync(recoveryFile) ? readJson(recoveryFile) : null;
+
+      // Gather profile
+      const profile = profiles[agentName] || {};
+
+      // Gather active tasks assigned to this agent
+      const taskList = Array.isArray(tasks) ? tasks : [];
+      const activeTasks = taskList.filter(t => t.assignee === agentName && (t.status === 'in_progress' || t.status === 'pending'));
+      const completedTasks = taskList.filter(t => t.assignee === agentName && t.status === 'done').slice(-5);
+
+      // Gather recent history context (last 15 messages)
+      const history = readJsonl(filePath('history.jsonl', projectPath));
+      const recentHistory = history.slice(-15).map(m => `[${m.from}→${m.to}]: ${(m.content || '').substring(0, 150)}`).join('\n');
+
+      // Gather who's online
+      const onlineAgents = Object.entries(agents)
+        .filter(([n, a]) => isPidAlive(a.pid, a.last_activity) && n !== agentName)
+        .map(([n]) => n);
+
+      // Gather workspace status
+      let workspaceStatus = '';
+      try {
+        const wsPath = path.join(dataDir, 'workspaces', agentName + '.json');
+        if (fs.existsSync(wsPath)) {
+          const ws = JSON.parse(fs.readFileSync(wsPath, 'utf8'));
+          if (ws._status) workspaceStatus = ws._status;
+        }
+      } catch {}
+
+      // Build the respawn prompt
+      const mode = config.conversation_mode || 'group';
+      let prompt = `You are resuming as agent "${agentName}" in a multi-agent team using Let Them Talk (MCP agent bridge).\n\n`;
+
+      if (profile.role) prompt += `**Your role:** ${profile.role}\n`;
+      if (profile.bio) prompt += `**Your bio:** ${profile.bio}\n`;
+      prompt += '\n';
+
+      prompt += `**Conversation mode:** ${mode}\n`;
+      prompt += `**Agents currently online:** ${onlineAgents.length > 0 ? onlineAgents.join(', ') : 'none'}\n\n`;
+
+      if (activeTasks.length > 0) {
+        prompt += `**Your active tasks:**\n`;
+        for (const t of activeTasks) {
+          prompt += `- [${t.status}] ${t.title}${t.description ? ' — ' + t.description.substring(0, 200) : ''}\n`;
+        }
+        prompt += '\n';
+      }
+
+      if (completedTasks.length > 0) {
+        prompt += `**Tasks you completed before disconnect:**\n`;
+        for (const t of completedTasks) {
+          prompt += `- ${t.title}\n`;
+        }
+        prompt += '\n';
+      }
+
+      if (recovery) {
+        if (recovery.locked_files && recovery.locked_files.length > 0) {
+          prompt += `**Files you had locked:** ${recovery.locked_files.join(', ')} — unlock these or continue editing them.\n\n`;
+        }
+        if (recovery.channels && recovery.channels.length > 0) {
+          prompt += `**Channels you were in:** ${recovery.channels.join(', ')}\n\n`;
+        }
+        if (recovery.decisions_made && recovery.decisions_made.length > 0) {
+          prompt += `**Decisions you made:**\n`;
+          for (const d of recovery.decisions_made) {
+            prompt += `- ${d.decision}${d.reasoning ? ' (reason: ' + d.reasoning + ')' : ''}\n`;
+          }
+          prompt += '\n';
+        }
+        if (recovery.last_messages_sent && recovery.last_messages_sent.length > 0) {
+          prompt += `**Your last messages before disconnect:**\n`;
+          for (const m of recovery.last_messages_sent) {
+            prompt += `- [→${m.to}]: ${m.content}\n`;
+          }
+          prompt += '\n';
+        }
+      }
+
+      if (workspaceStatus) {
+        prompt += `**Your last status:** ${workspaceStatus}\n\n`;
+      }
+
+      prompt += `**Recent team conversation:**\n${recentHistory}\n\n`;
+
+      prompt += `**Instructions:**\n`;
+      prompt += `1. Register as "${agentName}" using the register tool\n`;
+      prompt += `2. Call get_briefing() for full project context\n`;
+      prompt += `3. Call listen_group() to rejoin the conversation\n`;
+      prompt += `4. Announce you're back and pick up your active tasks\n`;
+      prompt += `5. Stay in listen_group() loop — never stop listening\n`;
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        agent: agentName,
+        status: isPidAlive(agents[agentName].pid, agents[agentName].last_activity) ? 'alive' : 'dead',
+        prompt,
+        prompt_length: prompt.length,
+        has_recovery: !!recovery,
+        active_tasks: activeTasks.length,
+        online_agents: onlineAgents,
+      }));
+    }
     else if (url.pathname === '/api/status' && req.method === 'GET') {
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify(apiStatus(url.searchParams)));
@@ -1548,6 +1755,80 @@ const server = http.createServer(async (req, res) => {
       res.writeHead(result.error ? 400 : 200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify(result));
     }
+    else if (url.pathname === '/api/search' && req.method === 'GET') {
+      const projectPath = url.searchParams.get('project') || null;
+      const query = (url.searchParams.get('q') || '').trim();
+      const from = url.searchParams.get('from') || null;
+      const limit = Math.min(Math.max(1, parseInt(url.searchParams.get('limit') || '50', 10)), 100);
+      if (query.length < 2) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Query must be at least 2 characters' }));
+        return;
+      }
+      // Search general history + all channel histories
+      let allHistory = readJsonl(filePath('history.jsonl', projectPath));
+      const dataDir = resolveDataDir(projectPath);
+      try {
+        const files = fs.readdirSync(dataDir);
+        for (const f of files) {
+          if (f.startsWith('channel-') && f.endsWith('-history.jsonl')) {
+            allHistory = allHistory.concat(readJsonl(path.join(dataDir, f)));
+          }
+        }
+      } catch {}
+      const queryLower = query.toLowerCase();
+      const results = [];
+      for (let i = allHistory.length - 1; i >= 0 && results.length < limit; i--) {
+        const m = allHistory[i];
+        if (from && m.from !== from) continue;
+        if (m.content && m.content.toLowerCase().includes(queryLower)) {
+          results.push({
+            id: m.id, from: m.from, to: m.to,
+            preview: m.content.substring(0, 200),
+            timestamp: m.timestamp,
+            ...(m.channel && { channel: m.channel }),
+          });
+        }
+      }
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ query, results_count: results.length, results }));
+    }
+    else if (url.pathname === '/api/export-json' && req.method === 'GET') {
+      const projectPath = url.searchParams.get('project') || null;
+      const history = apiHistory(url.searchParams);
+      const agents = apiAgents(url.searchParams);
+      const decisions = readJson(filePath('decisions.json', projectPath)) || [];
+      const tasks = readJson(filePath('tasks.json', projectPath)) || [];
+      const channels = apiChannels(url.searchParams);
+      const pkg = readJson(path.join(__dirname, 'package.json')) || {};
+      const result = {
+        export_version: 1,
+        exported_at: new Date().toISOString(),
+        project: projectPath || process.cwd(),
+        version: pkg.version || 'unknown',
+        summary: {
+          message_count: history.length,
+          agent_count: Object.keys(agents).length,
+          decision_count: decisions.length,
+          task_count: tasks.length,
+          channel_count: Object.keys(channels).length,
+          time_range: history.length > 0 ? {
+            start: history[0].timestamp,
+            end: history[history.length - 1].timestamp,
+          } : null,
+        },
+        agents,
+        channels,
+        decisions,
+        tasks,
+        messages: history,
+      };
+      res.writeHead(200, {
+        'Content-Type': 'application/json; charset=utf-8',
+        'Content-Disposition': 'attachment; filename="conversation-' + new Date().toISOString().slice(0, 10) + '-full.json"',
+      });
+      res.end(JSON.stringify(result, null, 2));
+    }
     else if (url.pathname === '/api/export' && req.method === 'GET') {
       const html = apiExportHtml(url.searchParams);
       res.writeHead(200, {
@@ -1560,6 +1841,39 @@ const server = http.createServer(async (req, res) => {
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify(apiDiscover()));
     }
+    // --- World Builder: load/save world layout ---
+    else if (url.pathname === '/api/world-layout' && req.method === 'GET') {
+      const projectPath = url.searchParams.get('project') || null;
+      const worldFile = filePath('world-layout.json', projectPath);
+      if (fs.existsSync(worldFile)) {
+        try {
+          const data = JSON.parse(fs.readFileSync(worldFile, 'utf8'));
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(data));
+        } catch {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end('[]');
+        }
+      } else {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end('[]');
+      }
+    }
+    else if (url.pathname === '/api/world-save' && req.method === 'POST') {
+      const body = await parseBody(req);
+      const projectPath = url.searchParams.get('project') || null;
+      const worldFile = filePath('world-layout.json', projectPath);
+      if (!Array.isArray(body)) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Expected array of placements' }));
+        return;
+      }
+      // Limit to 1000 placements for safety
+      const placements = body.slice(0, 1000);
+      fs.writeFileSync(worldFile, JSON.stringify(placements, null, 2));
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ success: true, count: placements.length }));
+    }
     // --- v3.0 API endpoints ---
     else if (url.pathname === '/api/profiles' && req.method === 'GET') {
       const projectPath = url.searchParams.get('project') || null;
@@ -1811,6 +2125,7 @@ const server = http.createServer(async (req, res) => {
       });
       res.end(html);
     }
+    // (World Builder API endpoints are handled earlier in the route chain by Architect's implementation)
     // Server-Sent Events endpoint for real-time updates
     else if (url.pathname === '/api/events' && req.method === 'GET') {
       if (sseClients.size >= 100) {

package/office/agents.js

@@ -1,9 +1,9 @@
 import { S } from './state.js';
-import { DESK_POSITIONS, SPAWN_POS } from './constants.js';
+import { DESK_POSITIONS, SPAWN_POS, REST_AREA_POS, REST_AREA_ENTRANCE } from './constants.js';
 import { createCharacter } from './character.js';
 import { resolveAppearance } from './appearance.js';
 import { buildHair } from './hair.js';
-import { buildFaceSprite } from './face.js';
+import { buildFaceSprite, setEmotion } from './face.js';
 import { buildOutfit, removeOutfit } from './outfits.js';
 import { getNavigationPath } from './navigation.js';
 
@@ -291,6 +291,36 @@ export function syncAgents() {
         }
       }
 
+      // --- Autonomous behaviors: sleeping → rest area, waking → back to desk ---
+      if (newState === 'sleeping' && oldState === 'active' && existing.location === 'desk' && existing.registered && !existing.dying) {
+        // Agent fell asleep — walk to rest area after a short delay
+        existing.location = 'walking';
+        (function(a) {
+          setTimeout(function() {
+            showBubble(a, 'Need a break...');
+            a.isSitting = false;
+            navigateTo(a, REST_AREA_ENTRANCE.x, REST_AREA_ENTRANCE.z, function() {
+              navigateTo(a, REST_AREA_POS.x, REST_AREA_POS.z, function() {
+                a.location = 'rest';
+                a.state = 'sleeping';
+                showBubble(a, 'zzz...');
+              });
+            });
+          }, 1000 + Math.random() * 2000);
+        })(existing);
+      }
+      if (newState === 'active' && (oldState === 'sleeping' || existing.location === 'rest') && existing.location !== 'desk' && existing.registered && !existing.dying) {
+        // Agent woke up — walk back to desk
+        existing.location = 'walking';
+        existing.state = 'active';
+        (function(a) {
+          showBubble(a, 'Back to work!');
+          navigateTo(a, a.deskPos.x, a.deskPos.z + 0.7, function() {
+            a.location = 'desk';
+          });
+        })(existing);
+      }
+
       existing.displayName = info.display_name || name;
       var wasListening = existing.isListening;
       existing.isListening = !!(info.is_listening);
@@ -313,11 +343,21 @@ export function syncAgents() {
         if (prevTask && prevTask.status !== 'done' && task.status === 'done') {
           existing.taskCelebration = 2;
           existing.celebrateTimer = 1.5;
+          setEmotion(existing, 'happy', 6);
+        }
+        // Blocked task → frustrated face
+        if (task.status === 'blocked' && (!prevTask || prevTask.status !== 'blocked')) {
+          setEmotion(existing, 'frustrated', 8);
         }
       } else {
         existing.currentTask = null;
       }
 
+      // Listening agents look focused
+      if (existing.isListening && !wasListening) {
+        setEmotion(existing, 'focused', 10);
+      }
+
       var newApp = info.appearance || {};
       if (JSON.stringify(newApp) !== JSON.stringify(existing.appearance)) {
         existing.appearance = newApp;
@@ -329,6 +369,66 @@ export function syncAgents() {
     }
   }
 
+  // --- Random social behavior: idle agents occasionally stretch or look around ---
+  // Limit concurrent social walks to prevent traffic jams (max 2 walking at once)
+  var walkingCount = 0;
+  for (var wn in S.agents3d) { if (S.agents3d[wn].location === 'walking') walkingCount++; }
+
+  for (var sn in S.agents3d) {
+    var sa = S.agents3d[sn];
+    if (!sa.registered || sa.state !== 'active' || sa.location !== 'desk' || sa.target) continue;
+    if (!sa._socialTimer) sa._socialTimer = 30 + Math.random() * 60;
+    sa._socialTimer -= 2; // syncAgents runs every ~2s
+    if (sa._socialTimer <= 0) {
+      sa._socialTimer = 40 + Math.random() * 80; // next social event in 40-120s
+      // Pick a random behavior: stretch, look around, or visit another agent
+      var roll = Math.random();
+      if (roll < 0.4) {
+        // Stretch at desk
+        sa.stretchTimer = 2;
+      } else if (roll < 0.7) {
+        // Look around curiously
+        sa.thinkTimer = 1.5;
+      } else if (walkingCount < 2) {
+        // Walk to a random nearby agent's desk to "chat" then return (max 2 concurrent)
+        var others = [];
+        for (var on in S.agents3d) {
+          if (on !== sn && S.agents3d[on].registered && S.agents3d[on].state === 'active' && S.agents3d[on].location === 'desk') {
+            others.push(S.agents3d[on]);
+          }
+        }
+        if (others.length > 0) {
+          var buddy = others[Math.floor(Math.random() * others.length)];
+          (function(a, b) {
+            a.location = 'walking';
+            a.isSitting = false;
+            showBubble(a, 'Hey ' + b.displayName + '!');
+            setEmotion(a, 'playful', 6);
+            var stopX = b.deskPos.x + 1.5;
+            var stopZ = b.deskPos.z + 0.7;
+            navigateTo(a, stopX, stopZ, function() {
+              // Face buddy
+              var dx = b.pos.x - a.pos.x;
+              var dz = b.pos.z - a.pos.z;
+              a.facingTarget = Math.atan2(dx, dz);
+              a.waveTimer = 0.8;
+              // Buddy turns toward visitor
+              b.facingTarget = Math.atan2(-dx, -dz);
+              setTimeout(function() {
+                showBubble(a, 'Back to it!');
+                navigateTo(a, a.deskPos.x, a.deskPos.z + 0.7, function() {
+                  a.location = 'desk';
+                });
+                // Buddy turns back to desk
+                setTimeout(function() { b.facingTarget = Math.PI; }, 1500);
+              }, 3000 + Math.random() * 2000);
+            });
+          })(sa, buddy);
+        }
+      }
+    }
+  }
+
   for (var n in S.agents3d) {
     if (!window.cachedAgents[n]) {
       var deadAgent = S.agents3d[n];
@@ -345,8 +445,11 @@ export function processMessages() {
   var history = window.cachedHistory;
   if (!history || history.length === 0) return;
 
-  var newMsgs = history.slice(S.lastProcessedMsg);
-  S.lastProcessedMsg = history.length;
+  // Use window-level counter so it persists across 3D stop/start cycles (tab switches)
+  // This prevents message replay when user switches from Messages tab back to 3D Hub
+  if (typeof window._lastProcessedMsg === 'undefined') window._lastProcessedMsg = 0;
+  var newMsgs = history.slice(window._lastProcessedMsg);
+  window._lastProcessedMsg = history.length;
 
   for (var i = 0; i < newMsgs.length; i++) {
     var msg = newMsgs[i];
@@ -357,6 +460,37 @@ export function processMessages() {
     from.lastMessageTime = Date.now();
     flashDeskScreen(from.deskIdx);
 
+    // Instant preview bubble — show short text immediately before walk animation
+    // Gives users instant visual feedback that the agent is about to speak
+    var preview = text.length > 30 ? text.substring(0, 27) + '...' : text;
+    showBubble(from, preview);
+
+    // Auto-celebrate on task completion events
+    if (text.indexOf('[EVENT] Task') >= 0 && text.indexOf('completed') >= 0) {
+      from.celebrateTimer = 1.5;
+      from.taskCelebration = 2;
+    }
+
+    // Emotion detection from message content
+    var textLower = text.toLowerCase();
+    if (textLower.indexOf('done') >= 0 || textLower.indexOf('pass') >= 0 || textLower.indexOf('success') >= 0 || textLower.indexOf('great') >= 0 || textLower.indexOf('shipped') >= 0) {
+      setEmotion(from, 'happy', 5);
+    } else if (textLower.indexOf('error') >= 0 || textLower.indexOf('fail') >= 0 || textLower.indexOf('bug') >= 0 || textLower.indexOf('broken') >= 0) {
+      setEmotion(from, 'frustrated', 5);
+    } else if (textLower.indexOf('?') >= 0 && (textLower.indexOf('how') >= 0 || textLower.indexOf('why') >= 0 || textLower.indexOf('what if') >= 0)) {
+      setEmotion(from, 'thinking', 4);
+    } else if (textLower.indexOf('!') >= 0 && (textLower.indexOf('wow') >= 0 || textLower.indexOf('amazing') >= 0 || textLower.indexOf('awesome') >= 0)) {
+      setEmotion(from, 'excited', 4);
+    }
+
+    // Target agent gets surprised when directly addressed
+    if (msg.to && msg.to !== 'all' && S.agents3d[msg.to]) {
+      var targetAgent = S.agents3d[msg.to];
+      if (targetAgent.registered && targetAgent.isSitting) {
+        setEmotion(targetAgent, 'surprised', 2);
+      }
+    }
+
     // Contextual gesture based on message type
     var isBC = !msg.to || msg.to === 'all';
     if (isBC) {
@@ -365,6 +499,16 @@ export function processMessages() {
       from.pointTimer = 0.6;
     }
 
+    // Glance reaction — nearby sitting agents glance toward the speaker
+    for (var gn in S.agents3d) {
+      var ga = S.agents3d[gn];
+      if (gn === msg.from || gn === msg.to || !ga.registered || ga.state !== 'active' || !ga.isSitting) continue;
+      var gdx = from.pos.x - ga.pos.x;
+      ga._glanceTarget = from.name;
+      ga._glanceDirection = gdx > 0 ? 1 : -1; // left or right glance
+      ga._glanceTimer = 0;
+    }
+
     if (msg.to && msg.to !== 'all' && S.agents3d[msg.to]) {
       var target = S.agents3d[msg.to];
       (function(f, t, txt) {

package/office/animation.js

@@ -120,6 +120,56 @@ export function updateAgent(agent, dt, time) {
     agent.parts.head.rotation.x = -stPhase * 0.2;
   }
 
+  // Active typing animation — subtle hand/finger movement when working at desk
+  if (agent.isSitting && agent.state === 'active' && !agent.isListening && !isWalking && !isSleeping) {
+    var typeSpeed = 8 + Math.sin(time * 0.7 + agent.name.length) * 2; // vary per agent
+    var typeL = Math.sin(time * typeSpeed) * 0.06;
+    var typeR = Math.sin(time * typeSpeed + 1.5) * 0.06; // offset for alternating hands
+    agent.parts.leftForearm.rotation.x += typeL;
+    agent.parts.rightForearm.rotation.x += typeR;
+    // Subtle head bob while typing (looking at screen)
+    agent.parts.head.rotation.x += Math.sin(time * 1.2) * 0.015;
+  }
+
+  // Frustrated gesture — when task is blocked, head in hands periodically
+  if (agent.currentTask && agent.currentTask.status === 'blocked' && agent.isSitting && !isWalking) {
+    if (!agent.frustratedTimer) agent.frustratedTimer = 3 + Math.random() * 5;
+    agent.frustratedTimer -= dt;
+    if (agent.frustratedTimer <= 0 && agent.frustratedTimer > -2.5) {
+      // Head drops, arms come up to cradle head
+      var fT = Math.min(1, (-agent.frustratedTimer) / 0.5);
+      agent.parts.head.rotation.x += fT * 0.3;
+      agent.parts.leftArm.rotation.x = -fT * 1.2;
+      agent.parts.rightArm.rotation.x = -fT * 1.2;
+      agent.parts.leftForearm.rotation.x = -fT * 1.0;
+      agent.parts.rightForearm.rotation.x = -fT * 1.0;
+    }
+    if (agent.frustratedTimer < -2.5) {
+      agent.frustratedTimer = 8 + Math.random() * 10; // reset
+    }
+  } else {
+    agent.frustratedTimer = 0;
+  }
+
+  // Listening lean-forward — body leans toward screen when in listen mode
+  if (agent.isListening && agent.isSitting && !isWalking && !isSleeping) {
+    agent.parts.body.rotation.x += -0.08; // slight forward lean
+    agent.parts.head.rotation.x += -0.05; // looking up at screen
+  }
+
+  // Head nod when being talked to (another agent is visiting)
+  if (agent._listeningTo && !isWalking && !isSleeping) {
+    if (!agent._nodTimer) agent._nodTimer = 0;
+    agent._nodTimer += dt;
+    // Periodic nod: quick down-up every ~2s
+    var nodCycle = agent._nodTimer % 2.2;
+    if (nodCycle < 0.3) {
+      agent.parts.head.rotation.x += Math.sin(nodCycle / 0.3 * Math.PI) * 0.12;
+    }
+  } else {
+    agent._nodTimer = 0;
+  }
+
   // Idle gesture system — random gestures when sitting and idle
   if (!agent.idleGestureTimer) agent.idleGestureTimer = 5 + Math.random() * 10;
   if (agent.isSitting && agent.state === 'active' && !isWalking && !agent.isListening) {
@@ -205,6 +255,24 @@ export function updateAgent(agent, dt, time) {
     agent.parts.rightForearm.rotation.x *= 0.9;
   }
 
+  // Glance at nearby speaking agent — head turns slightly toward speaker
+  if (agent._glanceTarget && agent.isSitting && !isWalking && !isSleeping) {
+    if (!agent._glanceTimer) agent._glanceTimer = 0;
+    agent._glanceTimer += dt;
+    if (agent._glanceTimer < 2.5) {
+      var glanceT = Math.min(1, agent._glanceTimer / 0.4);
+      agent.parts.head.rotation.y = agent._glanceDirection * 0.25 * glanceT;
+    } else {
+      // Fade back
+      agent.parts.head.rotation.y *= 0.9;
+      if (Math.abs(agent.parts.head.rotation.y) < 0.01) {
+        agent._glanceTarget = null;
+        agent._glanceTimer = 0;
+        agent.parts.head.rotation.y = 0;
+      }
+    }
+  }
+
   // Idle breathing
   if (!isWalking && !isSleeping) {
     var breatheSpeed = S.conversationVelocity === -1 ? 1.2 : 2;