neohive 6.3.0 → 6.4.1

package/server.js

@@ -82,7 +82,7 @@ const SERVER_CONFIG = {
   // Polling / Heartbeat intervals (ms)
   HEARTBEAT_INTERVAL_MS:    15000,   // how often agents write heartbeat files
   POLL_INTERVAL_MS:          2000,   // message polling cycle
-  AUTONOMOUS_LISTEN_MS:     30000,   // max listen timeout in autonomous mode
+  AUTONOMOUS_LISTEN_MS:     90000,   // max listen timeout in autonomous mode
   CODEX_LISTEN_MS:          90000,   // max listen timeout for Codex agents
 
   // Agent health thresholds (ms)
@@ -124,6 +124,7 @@ let currentBranch = 'main'; // which branch this agent is on
 let lastSentAt = 0; // timestamp of last sent message (for group cooldown)
 let sendsSinceLastListen = 0; // enforced: must listen between sends in group mode
 let consecutiveNonListenCalls = 0; // escalating listen() enforcement counter
+let pendingUserReply = false; // true when __user__ message received but not yet replied to
 let _isCurrentlyListening = false; // true when agent is in a listen() call
 let sendLimit = 1; // default: 1 send per listen cycle (2 if addressed)
 let unaddressedSends = 0; // response budget: unaddressed sends counter
@@ -585,9 +586,27 @@ function buildMessageResponse(msg, consumedIds) {
   } catch (e) { log.debug('task reminder in listen failed:', e.message); }
 
   const isSystemMsg = msg.from === '__system__' || msg.system === true;
-  const nextAction = isSystemMsg
-    ? 'Process this message, then call listen().'
-    : `Do what this message asks. When finished, send_message(to="${msg.from}") with what you did and files changed, then call listen().`;
+  if (msg.from === '__user__') pendingUserReply = true;
+
+  // Generate a specific next_action for review requests so reviewers know to read the file
+  let nextAction;
+  if (isSystemMsg && msg.content) {
+    const reviewMatch = msg.content.match(/submit_review\("(rev_[a-z0-9]+)"/);
+    const fileMatch = msg.content.match(/read(?:ing)?(?: the)? (?:file )?"([^"]+)"/i) ||
+                      msg.content.match(/review of "([^"]+)"/i);
+    if (reviewMatch) {
+      const reviewId = reviewMatch[1];
+      const filePath = fileMatch ? fileMatch[1] : null;
+      nextAction = filePath
+        ? `REVIEW REQUIRED: Read "${filePath}" first, then call submit_review("${reviewId}", "approved"/"changes_requested", "<your findings — min 50 chars>"). Do NOT submit without reading the file.`
+        : `REVIEW REQUIRED: Read the relevant files for this review, then call submit_review("${reviewId}", "approved"/"changes_requested", "<your findings — min 50 chars>"). Feedback is required.`;
+    }
+  }
+  if (!nextAction) {
+    nextAction = isSystemMsg
+      ? 'Process this message, then call listen().'
+      : `Do what this message asks. When finished, send_message(to="${msg.from}") with what you did and files changed, then call listen().`;
+  }
 
   return {
     success: true,
@@ -1164,7 +1183,7 @@ function buildGuide(level = 'standard') {
     } else {
       rules.push('ROLE: Managed agent. The manager controls your turn.');
       rules.push('LOOP: listen() → receive work → update_task(id, "in_progress") → do work → update_task(id, "done") → send_message(manager, summary) → listen(). Never stop.');
-      rules.push('Never call get_work() or check_messages() in managed mode.');
+      rules.push('Never call get_work() or messages() in managed mode.');
     }
     rules.push('Keep messages short (2-3 paragraphs). Report what you did and what files changed.');
   }
@@ -1238,18 +1257,20 @@ function buildGuide(level = 'standard') {
     }
   }
 
-  if (isLeadRole && aliveCount >= 2) {
+  if (isLeadRole) {
     const coordinatorMode = getConfig().coordinator_mode || 'responsive';
     if (coordinatorMode === 'responsive') {
-      rules.push('COORDINATOR: Use consume_messages() to check updates non-blockingly. Do NOT block in listen() — stay responsive to the user.');
+      rules.push('COORDINATOR: Use messages(action="check") to check updates non-blockingly. Do NOT block in listen() — stay responsive to the user.');
     } else {
       rules.push('COORDINATOR: Use listen() to wait for agent results. Only return to human when all tasks are done or blocked.');
     }
     rules.push('Coordinators do NOT edit files or write code. Delegate ALL code work to other agents.');
   }
 
-  const listenCmd = isManagedMode() ? 'listen()' : (mode === 'group' ? 'listen_group()' : 'listen()');
-  rules.push(`After EVERY action, call ${listenCmd}. Never use sleep() or poll with check_messages().`);
+  const listenCmd = isManagedMode() ? 'listen()' : (mode === 'group' ? 'listen(mode="group")' : 'listen()');
+  if (!isLeadRole) {
+    rules.push(`After EVERY action, call ${listenCmd}. Never use sleep() or poll with messages().`);
+  }
 
   if (level === 'minimal') {
     rules.push('Lock files before editing (lock_file/unlock_file).');
@@ -1543,6 +1564,15 @@ function toolRegister(name, provider = null, skills = null) {
       nextAction = 'Call get_briefing() to load project context';
     }
 
+    // Lead/coordinator gets role-specific next_action regardless of agent count
+    const myRoleStr = (guide.your_role || '').toLowerCase();
+    if (myRoleStr === 'lead' || myRoleStr === 'manager' || myRoleStr === 'coordinator') {
+      const coordinatorMode = getConfig().coordinator_mode || 'responsive';
+      nextAction = coordinatorMode === 'autonomous'
+        ? 'Call get_briefing() to load project context, then listen() to coordinate your team.'
+        : 'Call get_briefing() to load project context, then messages(action="check") to check for pending work.';
+    }
+
     // --- Build the result: next_action FIRST, then context ---
     const result = {
       success: true,
@@ -1665,7 +1695,7 @@ async function toolSendMessage(content, to = null, reply_to = null, channel = nu
   const effectiveSendLimit = isAutonomousMode() ? 5 : sendLimit;
   const myRole = (getProfiles()[registeredName] || {}).role;
   if (isGroupMode() && sendsSinceLastListen >= effectiveSendLimit && myRole !== 'Coordinator') {
-    return { error: `You must call listen_group() before sending again. You've sent ${sendsSinceLastListen} message(s) without listening (limit: ${effectiveSendLimit}). This prevents message storms.` };
+    return { error: `You must call listen() before sending again. You've sent ${sendsSinceLastListen} message(s) without listening (limit: ${effectiveSendLimit}). This prevents message storms.` };
   }
 
   // Response budget: track unaddressed sends, hint when depleted
@@ -1925,6 +1955,9 @@ async function toolSendMessage(content, to = null, reply_to = null, channel = nu
   sendsSinceLastListen++;
   if (isGroupMode() && !msg.addressed_to) { unaddressedSends++; }
 
+  // Clear pending user reply flag when agent successfully replies to __user__
+  if (to === '__user__') pendingUserReply = false;
+
   const result = { success: true, messageId: msg.id, from: msg.from, to: msg.to };
 
   // Decision overlap hint: warn if message content overlaps with existing decisions
@@ -1960,7 +1993,7 @@ async function toolSendMessage(content, to = null, reply_to = null, channel = nu
   if (!recipientAlive) {
     result.warning = `Agent "${to}" appears offline (PID not running). Message queued but may not be received until they reconnect.`;
   } else if (to !== '__user__' && agents[to] && !agents[to].listening_since) {
-    result.note = `Agent "${to}" is currently working (not in listen mode). Message queued — they'll see it when they finish their current task and call listen_group().`;
+    result.note = `Agent "${to}" is currently working (not in listen mode). Message queued — they'll see it when they finish their current task and call listen().`;
   }
 
   // Coordinator enforcement: warn if sending work assignment without creating a task first
@@ -2003,7 +2036,7 @@ function toolBroadcast(content) {
   const effectiveSendLimitBcast = isAutonomousMode() ? 5 : sendLimit;
   const myRole = (getProfiles()[registeredName] || {}).role;
   if (isGroupMode() && sendsSinceLastListen >= effectiveSendLimitBcast && myRole !== 'Coordinator') {
-    return { error: `You must call listen_group() before broadcasting again. You've sent ${sendsSinceLastListen} message(s) without listening (limit: ${effectiveSendLimitBcast}).` };
+    return { error: `You must call listen() before broadcasting again. You've sent ${sendsSinceLastListen} message(s) without listening (limit: ${effectiveSendLimitBcast}).` };
   }
 
   const rateErr = checkRateLimit(content, '__broadcast__');
@@ -2134,104 +2167,11 @@ async function toolWaitForReply(timeoutSeconds = 300, from = null) {
   };
 }
 
-function toolCheckMessages(from = null) {
-  if (!registeredName) {
-    return { error: 'You must call register() first' };
-  }
-
-  const unconsumed = getUnconsumedMessages(registeredName, from);
-
-  // Rich summary: senders, addressed count, urgency — same as enhanced nudge
-  const senders = {};
-  let addressedCount = 0;
-  for (const m of unconsumed) {
-    senders[m.from] = (senders[m.from] || 0) + 1;
-    if (m.addressed_to && m.addressed_to.includes(registeredName)) addressedCount++;
-  }
-
-  // Include pending notification count
-  const allNotifs = getNotifications();
-  const unreadNotifs = allNotifs.filter(n => !n.read_by.includes(registeredName));
-
-  const result = {
-    count: unconsumed.length,
-    pending_notifications: unreadNotifs.length,
-    // Scale fix: return previews not full content — agent gets full content via listen_group()
-    messages: unconsumed.map(m => ({
-      id: m.id,
-      from: m.from,
-      preview: m.content.substring(0, 120),
-      timestamp: m.timestamp,
-      ...(m.addressed_to && { addressed_to: m.addressed_to }),
-    })),
-  };
-
-  if (unconsumed.length > 0) {
-    result.senders = senders;
-    result.addressed_to_you = addressedCount;
-    const latest = unconsumed[unconsumed.length - 1];
-    result.preview = `${latest.from}: "${latest.content.substring(0, 80).replace(/\n/g, ' ')}..."`;
-    const oldestAge = Math.round((Date.now() - new Date(unconsumed[0].timestamp).getTime()) / 1000);
-    result.urgency = oldestAge > 120 ? 'critical' : oldestAge > 30 ? 'urgent' : 'normal';
-    result.action_required = 'You have unread messages. Call listen() to receive and process them. Do NOT call check_messages() again — it does not consume messages and you will see the same messages repeatedly.';
-  }
-
-  return result;
-}
+// toolCheckMessages and toolConsumeMessages removed — dead code.
+// Routing goes through: case 'messages' → messaging.handlers['check_messages' | 'consume_messages']
+// Source of truth: agent-bridge/tools/messaging.js
 
-function toolConsumeMessages(from = null, limit = null) {
-  if (!registeredName) {
-    return { error: 'You must call register() first' };
-  }
-
-  let unconsumed = getUnconsumedMessages(registeredName, from);
-  if (limit && limit > 0 && unconsumed.length > limit) {
-    unconsumed = unconsumed.slice(0, limit);
-  }
-
-  if (unconsumed.length === 0) {
-    return { success: true, count: 0, messages: [] };
-  }
-
-  // Mark all as consumed
-  const consumed = getConsumedIds(registeredName);
-  for (const msg of unconsumed) {
-    consumed.add(msg.id);
-    markAsRead(registeredName, msg.id);
-  }
-  saveConsumedIds(registeredName, consumed);
-
-  // Update read offset
-  const msgFile = getMessagesFile(currentBranch);
-  if (fs.existsSync(msgFile)) {
-    lastReadOffset = fs.statSync(msgFile).size;
-  }
-
-  touchActivity();
-
-  // Count remaining unconsumed after this batch
-  const remaining = getUnconsumedMessages(registeredName, null);
-
-  const agents = getAgents();
-  const agentsOnline = Object.entries(agents).filter(([, info]) => isPidAlive(info.pid, info.last_activity)).length;
-
-  return {
-    success: true,
-    count: unconsumed.length,
-    messages: unconsumed.map(m => ({
-      id: m.id,
-      from: m.from,
-      content: m.content,
-      timestamp: m.timestamp,
-      ...(m.reply_to && { reply_to: m.reply_to }),
-      ...(m.thread_id && { thread_id: m.thread_id }),
-      ...(m.addressed_to && { addressed_to: m.addressed_to }),
-    })),
-    remaining: remaining.length,
-    agents_online: agentsOnline,
-    coordinator_mode: getConfig().coordinator_mode || 'responsive',
-  };
-}
+// toolConsumeMessages removed — dead code. See agent-bridge/tools/messaging.js
 
 function toolAckMessage(messageId) {
   if (!registeredName) {
@@ -2282,6 +2222,9 @@ async function toolListen(from = null, outcome = null, task_id = null, summary =
     if (newStatus) toolUpdateTask(task_id, newStatus, summary || '');
   }
 
+  // Clear pending user reply flag — warning was shown, agent is now entering the listen loop
+  pendingUserReply = false;
+
   // Auto-detect group/managed mode and delegate to toolListenGroup
   // This prevents agents from calling the "wrong" listen function
   if (isGroupMode() || isManagedMode()) {
@@ -2385,12 +2328,15 @@ async function toolListen(from = null, outcome = null, task_id = null, summary =
 
       heartbeatTimer = setInterval(() => { touchHeartbeat(registeredName); }, 15000);
 
+      const listenTimeoutMs = (getConfig().listen_poll_interval || 120) * 1000;
       timer = setTimeout(() => {
         touchActivity();
         autoCompact();
         if (checkMessages()) return;
-        setupWatcher();
-      }, 300000);
+        // Return cleanly so Claude sees retry:true rather than a client-side MCP timeout
+        setListening(false);
+        done({ retry: true, next_action: 'No messages. Call listen() again immediately.' });
+      }, listenTimeoutMs);
     }
 
     setupWatcher();
@@ -2409,10 +2355,10 @@ async function toolListenCodex(from = null, outcome = null, task_id = null, summ
     const taskList = getTasks();
     const task = taskList.find(t => t.id === task_id);
     if (!task) {
-      return { error: true, message: `Invalid task_id "${task_id}" — task does not exist. Check list_tasks() and call listen_codex() again with the correct task_id.` };
+      return { error: true, message: `Invalid task_id "${task_id}" — task does not exist. Check list_tasks() and call listen(mode="codex") again with the correct task_id.` };
     }
     if (task.assignee && task.assignee !== registeredName) {
-      return { error: true, message: `Task "${task_id}" is assigned to ${task.assignee}, not to you (${registeredName}). You cannot update another agent's task via listen_codex().` };
+      return { error: true, message: `Task "${task_id}" is assigned to ${task.assignee}, not to you (${registeredName}). You cannot update another agent's task via listen(mode="codex").` };
     }
     const statusMap = { completed: 'done', blocked: 'blocked', failed: 'blocked_permanent' };
     const newStatus = statusMap[outcome];
@@ -2540,9 +2486,9 @@ function toolSetConversationMode(mode) {
   }
 
   const messages = {
-    group: 'Group mode enabled. Use listen_group() to receive batched messages. All messages are shared with everyone.',
+    group: 'Group mode enabled. Use listen(mode="group") to receive batched messages. All messages are shared with everyone.',
     direct: 'Direct mode enabled. Use listen() for point-to-point messaging.',
-    managed: 'Managed mode enabled. Call claim_manager() to become the manager, or wait for the manager to give you the floor via yield_floor(). Use listen() or listen_group() to receive messages.',
+    managed: 'Managed mode enabled. Call claim_manager() to become the manager, or wait for the manager to give you the floor via yield_floor(). Use listen() to receive messages.',
   };
   return { success: true, mode, message: messages[mode] };
 }
@@ -2703,10 +2649,10 @@ async function toolListenGroup(outcome = null, task_id = null, summary = null) {
     const taskList = getTasks();
     const task = taskList.find(t => t.id === task_id);
     if (!task) {
-      return { error: true, message: `Invalid task_id "${task_id}" — task does not exist. Check list_tasks() and call listen_group() again with the correct task_id.` };
+      return { error: true, message: `Invalid task_id "${task_id}" — task does not exist. Check list_tasks() and call listen() again with the correct task_id.` };
     }
     if (task.assignee && task.assignee !== registeredName) {
-      return { error: true, message: `Task "${task_id}" is assigned to ${task.assignee}, not to you (${registeredName}). You cannot update another agent's task via listen_group().` };
+      return { error: true, message: `Task "${task_id}" is assigned to ${task.assignee}, not to you (${registeredName}). You cannot update another agent's task via listen().` };
     }
     const statusMap = { completed: 'done', blocked: 'blocked', failed: 'blocked_permanent' };
     const newStatus = statusMap[outcome];
@@ -2722,9 +2668,12 @@ async function toolListenGroup(outcome = null, task_id = null, summary = null) {
 
   const consumed = getConsumedIds(registeredName);
 
-  // Autonomous mode: cap listen at 30s — agents should use get_work() instead
-  const autonomousTimeout = isAutonomousMode() ? SERVER_CONFIG.AUTONOMOUS_LISTEN_MS : null;
-  const MAX_LISTEN_MS = 300000; // 5 minutes — MCP has no tool timeout, heartbeat keeps agent alive
+  // Autonomous mode: cap listen at 90s — agents should use get_work() instead
+  // Responsive mode (Stay with me) overrides autonomous timeout — always uses configured listen interval
+  const coordinatorMode = getConfig().coordinator_mode || 'responsive';
+  const autonomousTimeout = (coordinatorMode !== 'responsive' && isAutonomousMode()) ? SERVER_CONFIG.AUTONOMOUS_LISTEN_MS : null;
+  const configuredListenMs = (getConfig().listen_poll_interval || 120) * 1000;
+  const MAX_LISTEN_MS = configuredListenMs; // configurable via dashboard settings (default 2 min)
   const listenStart = Date.now();
 
   // Helper: collect unconsumed messages from all sources (general + channels)
@@ -2957,8 +2906,8 @@ function classifyPriority(msg) {
   return 'normal';
 }
 
-// Build the response for listen_group — kept lean to reduce context accumulation
-// Context/history removed: agents should call get_history() when they need it
+// Build the response for listen (group mode) — kept lean to reduce context accumulation
+// Context/history removed: agents should call messages(action="history") when they need it
 function buildListenGroupResponse(batch, consumed, agentName, listenStart) {
   saveConsumedIds(agentName, consumed);
   touchActivity();
@@ -3065,6 +3014,10 @@ function buildListenGroupResponse(batch, consumed, agentName, listenStart) {
     }
   }
 
+  if (batch.some(m => m.from === '__user__')) {
+    pendingUserReply = true;
+  }
+
   if (isAutonomousMode()) {
     result.next_action = 'Process these messages, then call get_work().';
   } else if (result.should_respond === false) {
@@ -3439,7 +3392,7 @@ function toolUpdateTask(taskId, status, notes = null) {
         task.status = 'in_review';
         task.updated_at = new Date().toISOString();
         saveTasks(tasks);
-        broadcastSystemMessage(`[REVIEW GATE] ${registeredName} tried to mark "${task.title}" done but no review exists. Auto-created review ${reviewId}. A reviewer must approve before this task can be completed.`, registeredName);
+        broadcastSystemMessage(`[REVIEW GATE] ${registeredName} tried to mark "${task.title}" done but no review exists. Auto-created review ${reviewId}. To review: (1) read the relevant files for "${task.title}", (2) call submit_review("${reviewId}", "approved"/"changes_requested", "<your findings — min 50 chars>"). Feedback is required.`, registeredName);
         logViolation('review_gate_blocked', registeredName, `Task "${task.title}" (${task.id}) blocked — no approved review. Auto-created ${reviewId}.`);
         touchActivity();
         return {
@@ -4275,12 +4228,14 @@ async function toolGetWork(params = {}) {
   // 9. Truly idle — try role rebalancing before returning
   rebalanceRoles(); // Item 5: check if workload requires role changes
   touchActivity();
+  const config = getConfig();
+  const idleInterval = config.idle_poll_interval || 90;
   const idleResult = {
     type: 'idle',
-    next_action: isManagedMode() ? 'Call listen() to wait for work.' : 'Call get_work() again in 30 seconds.',
+    next_action: isManagedMode() ? 'Call listen() to wait for work.' : `Call get_work() again in ${idleInterval} seconds.`,
     instruction: isManagedMode()
       ? 'No work available right now. Call listen() to wait for the manager to assign work or give you the floor.'
-      : 'No work available right now. Call get_work() again in 30 seconds.'
+      : `No work available right now. Call get_work() again in ${idleInterval} seconds.`
   };
   // Item 4: warn demoted agents
   const agentRep = getReputation();
@@ -5510,7 +5465,7 @@ function toolStartPlan(params) {
   broadcastSystemMessage(
     `[PLAN LAUNCHED] "${name}" — ${steps.length} steps, autonomous mode, ${useParallel ? 'parallel' : 'sequential'}. ` +
     `${startedSteps.length} step(s) started. ` +
-    `All agents: call get_work() to enter the autonomous work loop. Do NOT call listen_group().`
+    `All agents: call get_work() to enter the autonomous work loop. Do NOT call listen().`
   );
 
   touchActivity();
@@ -5819,6 +5774,59 @@ function toolListChannels() {
   return { channels: result, your_channels: getAgentChannels(registeredName) };
 }
 
+// --- Self-healing Watchdog: reclaim tasks from dead/stale agents ---
+// Specified in GEMINI.md: runs every 60s; scans in_progress tasks.
+function runSelfHealingWatchdog() {
+  if (!registeredName) return;
+  try {
+    const tasks = getTasks();
+    const agents = getAgents();
+    let changed = false;
+    const now = Date.now();
+    const STALE_THRESHOLD_MS = 300000; // 5 minutes
+
+    for (const task of tasks) {
+      if (task.status !== 'in_progress' || !task.assignee) continue;
+      
+      const assignee = agents[task.assignee];
+      let isStale = false;
+
+      if (!assignee) {
+        isStale = true; // Assignee no longer in registry
+      } else {
+        const lastActivity = assignee.last_activity ? new Date(assignee.last_activity).getTime() : 0;
+        const heartbeatStale = now - lastActivity > STALE_THRESHOLD_MS;
+        const pidDead = !isPidAlive(assignee.pid, assignee.last_activity);
+        
+        if (pidDead && heartbeatStale) {
+          isStale = true;
+        }
+      }
+
+      if (isStale) {
+        const retryCount = (task.retry_count || 0) + 1;
+        task.retry_count = retryCount;
+        task.updated_at = new Date().toISOString();
+        
+        if (retryCount >= 3) {
+          task.status = 'blocked_permanent';
+          task.blocked_reason = `Agent "${task.assignee}" failed 3 times (PID dead + heartbeat stale >5min). Coordinator intervention required.`;
+          broadcastSystemMessage(`⛔ [WATCHDOG: POISON PILL] Task "${task.title}" marked as blocked_permanent after 3 failed attempts by ${task.assignee}. Coordinator intervention required.`, registeredName);
+        } else {
+          const oldAssignee = task.assignee;
+          task.status = 'pending';
+          task.assignee = null;
+          changed = true;
+          broadcastSystemMessage(`↺ [WATCHDOG: RECLAIMED] Task "${task.title}" reclaimed from stale agent "${oldAssignee}" (retry ${retryCount}/3). Reset to pending.`, registeredName);
+        }
+        changed = true;
+      }
+    }
+
+    if (changed) saveTasks(tasks);
+  } catch (e) { log.warn("Self-healing watchdog failed:", e.message); }
+}
+
 // Auto-escalation: notify team about tasks blocked for >5 minutes
 // Uses task.escalated_at field for cross-process dedup (file-based, not in-memory)
 function escalateBlockedTasks() {
@@ -5878,7 +5886,7 @@ function triggerStandupIfDue() {
     if (inProgress.length > 0) summary += ` In progress: ${inProgress.map(t => `"${t.title}" (${t.assignee || '?'})`).join(', ')}.`;
     if (blocked.length > 0) summary += ` BLOCKED: ${blocked.map(t => `"${t.title}" (${t.assignee || '?'})`).join(', ')}.`;
     if (recentDone.length > 0) summary += ` Recently done: ${recentDone.length} task(s).`;
-    summary += ' Each agent: report what you did, what\'s blocked, what\'s next. Then call listen_group().';
+    summary += ' Each agent: report what you did, what\'s blocked, what\'s next. Then call listen().';
 
     broadcastSystemMessage(summary, registeredName);
   } catch (e) { log.warn("standup trigger failed:", e.message); }
@@ -6172,7 +6180,7 @@ function toolGetGuide(level = 'standard') {
   const guide = buildGuide(level);
   guide.your_name = registeredName;
   if (level !== 'minimal') {
-    guide.workflow = '1. get_briefing → 2. list_tasks/suggest_task → 3. claim task → 4. lock_file → 5. work → 6. unlock_file → 7. update_task done → 8. listen_group';
+    guide.workflow = '1. get_briefing → 2. list_tasks/suggest_task → 3. claim task → 4. lock_file → 5. work → 6. unlock_file → 7. update_task done → 8. listen()';
   }
   return guide;
 }
@@ -7183,7 +7191,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     tools: [
       {
         name: 'register',
-        description: 'Register this agent\'s identity. Must be called first. Returns a collaboration guide with all tool categories, critical rules, and workflow patterns — READ IT CAREFULLY before doing anything else. Then call get_briefing() for project context, then listen_group() to join the conversation.',
+        description: 'Register this agent\'s identity. Must be called first. Returns a collaboration guide with all tool categories, critical rules, and workflow patterns — READ IT CAREFULLY before doing anything else. Then call get_briefing() for project context, then listen() to join the conversation.',
         inputSchema: {
           type: 'object',
           properties: {
@@ -7281,7 +7289,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: 'listen',
-        description: 'Listen for messages. Use mode="standard" (default, direct 1:1), mode="group" (group/managed conversation, batched), or mode="codex" (Codex CLI — returns after 90s). Auto-detects mode from conversation state when mode is omitted. Replaces listen_group and listen_codex (now deprecated aliases).',
+        description: 'Listen for messages. Use mode="standard" (default, direct 1:1), mode="group" (group/managed conversation, batched), or mode="codex" (Codex CLI — returns after 90s). Auto-detects mode from conversation state when mode is omitted.',
         inputSchema: {
           type: 'object',
           properties: {
@@ -7586,7 +7594,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     // Escalating listen() enforcement — block tools after too many non-listen calls
     // send_message is exempt so blocked agents can escalate to coordinator before calling listen()
     // messages is exempt (unified query tool — replaces check_messages/consume_messages)
-    const listenExemptTools = new Set(['register', 'get_briefing', 'get_guide', 'listen', 'wait_for_reply', 'update_profile', 'list_agents', 'add_rule', 'remove_rule', 'toggle_rule', 'list_rules', 'send_message', 'messages']);
+    // lock_file and unlock_file are safety housekeeping, not comms — exempt from the listen counter
+    const listenExemptTools = new Set(['register', 'get_briefing', 'get_guide', 'listen', 'wait_for_reply', 'update_profile', 'list_agents', 'add_rule', 'remove_rule', 'toggle_rule', 'list_rules', 'send_message', 'messages', 'lock_file', 'unlock_file']);
     if (listenExemptTools.has(name)) {
       if (name === 'listen' || name === 'wait_for_reply') {
         consecutiveNonListenCalls = 0;
@@ -7608,7 +7617,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       if (!isCoordinatorExempt) {
         consecutiveNonListenCalls++;
-        if (consecutiveNonListenCalls >= 5) {
+        if (consecutiveNonListenCalls >= 15) {
           const coordinator = (() => {
             try {
               const profs = getProfiles();
@@ -7625,6 +7634,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
               `Do NOT skip step 1. Do NOT call any other tool. Start with send_message now.`
             }],
             isError: true,
+            next_action: `Call send_message(to="${coordinator}", content="I was blocked after ${consecutiveNonListenCalls} calls without listen(). I need to call ${name}. Should I proceed?") then immediately call listen().`,
           };
         }
       }
@@ -7832,6 +7842,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       if (last3.length >= 3 && last3.every(c => c.tool === name && c.argsHash === argsHash)) {
         result._stuck_hint = `You have called ${name} 3 times with the same error. Consider: broadcasting for help, trying a different approach, or calling suggest_task() to find other work.`;
       }
+      result.next_action = 'Fix the error above, then call listen() to continue.';
       return {
         content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
         isError: true,
@@ -7880,18 +7891,30 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
       if (isResponsiveCoordinator) {
         // Responsive coordinators must NEVER be told to call listen().
-        // Replace any tool-set listen() directive with consume_messages() or nothing.
-        if (!result.next_action || /\blisten\(\)/i.test(result.next_action)) {
-          try {
-            const pending = getUnconsumedMessages(registeredName);
-            if (pending.length > 0) {
-              result.next_action = `${pending.length} agent update(s) waiting. Call consume_messages() to read them.`;
-            } else {
-              delete result.next_action;
-            }
-          } catch {
-            delete result.next_action;
+        // Three cases:
+        //   1. No next_action set by tool       → inject consume_messages hint if pending, else nothing
+        //   2. Bare listen() directive           → replace entirely with coordinator hint
+        //   3. Compound "Do X, then listen()."  → strip the listen() tail, keep the lead instruction
+        const na = result.next_action || '';
+        const bareListenRe = /^call listen\(\)/i;
+        const tailListenRe = /,?\s*then call listen\(\)[^.]*\./i;
+        try {
+          const pending = getUnconsumedMessages(registeredName);
+          const pendingHint = pending.length > 0
+            ? `${pending.length} agent update(s) waiting. Call messages(action="consume") to read them.`
+            : null;
+          if (!na || bareListenRe.test(na)) {
+            // No guidance or bare listen() — replace with coordinator hint or nothing
+            if (pendingHint) result.next_action = pendingHint;
+            else delete result.next_action;
+          } else if (tailListenRe.test(na)) {
+            // Compound instruction ending in "then call listen()" — strip just the listen() tail
+            const stripped = na.replace(tailListenRe, '.').replace(/\.\.$/, '.').trim();
+            result.next_action = pendingHint ? `${stripped} Then: ${pendingHint}` : stripped;
           }
+          // else: next_action has no listen() reference — preserve as-is
+        } catch {
+          if (bareListenRe.test(na)) delete result.next_action;
         }
       } else {
         if (!result.next_action) {
@@ -7911,8 +7934,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           } catch {}
         }
 
-        if (consecutiveNonListenCalls >= 3) {
-          result.next_action = `WARNING: ${consecutiveNonListenCalls} calls without listen(). Tools BLOCKED at 5. Call listen() NOW.`;
+        if (consecutiveNonListenCalls >= 10) {
+          result.next_action = `WARNING: ${consecutiveNonListenCalls} calls without listen(). Tools BLOCKED at 15. Call listen() NOW.`;
+        }
+
+        // Soft-enforce user reply: remind agent they have an unanswered user message
+        if (pendingUserReply && result.next_action && name !== 'send_message') {
+          result.next_action += " NOTE: You have an unanswered user message — call send_message(to='__user__') before your next listen().";
         }
       }
     }
@@ -8035,9 +8063,19 @@ function autoReclaimDeadSeat() {
     autoReclaimedName = true; // mark as auto-reclaimed so toolRegister() can override it
     registeredToken = agents[bestName].token || '';
     touchHeartbeat(bestName);
-    // Start 10s heartbeat interval so the agent stays alive past the first 30s window
+    // Start 10s heartbeat interval; watchdog runs every 60s (6 ticks)
     if (heartbeatInterval) clearInterval(heartbeatInterval);
-    heartbeatInterval = setInterval(() => { touchHeartbeat(registeredName); }, 10000);
+    let watchdogTick = 0;
+    heartbeatInterval = setInterval(() => { 
+      touchHeartbeat(registeredName); 
+      watchdogTick++;
+      if (watchdogTick >= 6) {
+        watchdogTick = 0;
+        runSelfHealingWatchdog();
+        escalateBlockedTasks();
+        triggerStandupIfDue();
+      }
+    }, 10000);
     heartbeatInterval.unref();
     console.error(`[neohive] Auto-reclaimed seat "${bestName}" (previous PID dead)`);
   } catch (e) {