neohive 6.0.2 → 6.1.0

package/server.js

@@ -15,13 +15,22 @@ const _log = require('./lib/logger');
 const _state = require('./lib/state');
 const _config = require('./lib/config');
 const _fileIo = require('./lib/file-io');
+const { cachedRead, invalidateCache, lockAgentsFile, unlockAgentsFile, lockConfigFile, unlockConfigFile, withFileLock, readJsonl, readJsonlFromOffset, tailReadJsonl, readJsonFile, writeJsonFile, registerFileCacheKey } = _fileIo;
 const _agents = require('./lib/agents');
 const _messaging = require('./lib/messaging');
+const _audit = require('./lib/audit');
 const _compact = require('./lib/compact');
+const { readIdeActivity, applyIdeActivityHint } = require('./lib/ide-activity');
 
-// --- Structured logging ---
-const LOG_LEVEL = (process.env.NEOHIVE_LOG_LEVEL || 'warn').toLowerCase();
+const DATA_DIR = _config.DATA_DIR;
+
+// Initialize audit logging
+_audit.init(DATA_DIR);
+
+const _envLog = process.env.NEOHIVE_LOG_LEVEL;
+const LOG_LEVEL = (_envLog != null && String(_envLog).trim() !== '' ? String(_envLog).trim() : 'warn').toLowerCase();
 const LOG_LEVELS = { error: 0, warn: 1, info: 2, debug: 3 };
+
 const log = {
   error: (...args) => { if (LOG_LEVELS[LOG_LEVEL] >= 0) process.stderr.write('[NEOHIVE:ERROR] ' + args.map(String).join(' ') + '\n'); },
   warn:  (...args) => { if (LOG_LEVELS[LOG_LEVEL] >= 1) process.stderr.write('[NEOHIVE:WARN] ' + args.map(String).join(' ') + '\n'); },
@@ -29,8 +38,17 @@ const log = {
   debug: (...args) => { if (LOG_LEVELS[LOG_LEVEL] >= 3) process.stderr.write('[NEOHIVE:DEBUG] ' + args.map(String).join(' ') + '\n'); },
 };
 
-// Data dir lives in the project where Claude Code runs, not where the package is installed
-const DATA_DIR = process.env.NEOHIVE_DATA_DIR || path.join(process.cwd(), '.neohive');
+const _rawNeohiveEnv = String(process.env.NEOHIVE_DATA_DIR || '');
+if (_rawNeohiveEnv && /\$\{|\$\s*workspaceFolder/i.test(_rawNeohiveEnv)) {
+  log.warn('[neohive] NEOHIVE_DATA_DIR looks unexpanded (' + _rawNeohiveEnv.substring(0, 60) + '…). Node will not substitute ${workspaceFolder}. Use an absolute path (re-run npx neohive init --cursor) or set env in Cursor. Effective DATA_DIR=' + DATA_DIR);
+}
+
+// Auto-migrate from .agent-bridge/ to .neohive/ (v5 → v6 rename)
+const _legacyDir = path.join(path.dirname(DATA_DIR), '.agent-bridge');
+if (!fs.existsSync(DATA_DIR) && fs.existsSync(_legacyDir)) {
+  try { fs.renameSync(_legacyDir, DATA_DIR); } catch (e) { log.warn('Legacy migration failed:', e.message); }
+}
+
 const MESSAGES_FILE = path.join(DATA_DIR, 'messages.jsonl');
 const HISTORY_FILE = path.join(DATA_DIR, 'history.jsonl');
 const AGENTS_FILE = path.join(DATA_DIR, 'agents.json');
@@ -46,15 +64,57 @@ const LOCKS_FILE = path.join(DATA_DIR, 'locks.json');
 const PROGRESS_FILE = path.join(DATA_DIR, 'progress.json');
 const VOTES_FILE = path.join(DATA_DIR, 'votes.json');
 const REVIEWS_FILE = path.join(DATA_DIR, 'reviews.json');
+const NOTIFICATIONS_FILE = path.join(DATA_DIR, 'notifications.json');
 const DEPS_FILE = path.join(DATA_DIR, 'dependencies.json');
 const REPUTATION_FILE = path.join(DATA_DIR, 'reputation.json');
 const COMPRESSED_FILE = path.join(DATA_DIR, 'compressed.json');
 const RULES_FILE = path.join(DATA_DIR, 'rules.json');
-// Plugins removed in v3.4.3 — unnecessary attack surface, CLIs have their own extension systems
+const AGENT_CARDS_FILE = path.join(DATA_DIR, 'agent-cards.json');
+const PUSH_REQUESTS_FILE = path.join(DATA_DIR, 'push-requests.json');
+const AUDIT_LOG_FILE = path.join(DATA_DIR, 'audit_log.jsonl');
+
+// ─────────────────────────────────────────────────────────────────────────────
+// SERVER_CONFIG — centralized constants (timeouts, thresholds, limits)
+// Override via environment variables where indicated.
+// ─────────────────────────────────────────────────────────────────────────────
+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
+  CODEX_LISTEN_MS:          90000,   // max listen timeout for Codex agents
+
+  // Agent health thresholds (ms)
+  AGENT_STALE_THRESHOLD_MS:  30000,  // last_activity age before PID check falls back to stale
+  AGENT_CACHE_TTL_MS:         5000,  // alive-status cache TTL
+  AGENT_UNRESPONSIVE_MS:    120000,  // not called listen() in > 2 min => unresponsive
+  AGENT_SNAPSHOT_MAX_AGE_MS: 3600000,// snapshot older than 1 hr => force refresh
+
+  // Message rate limits
+  RATE_LIMIT_WINDOW_MS:      30000,  // sliding window for per-agent send rate limit
+  CHANNEL_RATE_WINDOW_MS:    60000,  // sliding window for per-channel rate limit
+  BUDGET_RESET_MS:           60000,  // unaddressed-send budget resets every 60s
+
+  // Cache TTLs
+  READ_CACHE_DEFAULT_TTL_MS:  2000,  // default read cache TTL
+  WORD_CACHE_TTL_MS:         30000,  // word-split cache TTL for task routing
+
+  // Wait / Lock timeouts (ms)
+  FILE_LOCK_MAX_WAIT_MS:      5000,  // max wait to acquire a file lock
+  RETENTION_DEFAULT_HOURS:      24,  // default message retention period (hours)
+
+  // Message limits
+  HISTORY_LIMIT_DEFAULT:        50,  // default history page size
+  HISTORY_LIMIT_MAX:           500,  // max history page size
+  MSG_CONTENT_MAX_CHARS:     10000,  // max CLI message text length
+
+  // MCP tool timeouts (seconds)
+  MCP_TOOL_TIMEOUT_S:          300,  // default MCP tool timeout used in IDE configs
+};
 
-// In-memory state for this process
 let registeredName = null;
 let registeredToken = null; // auth token for re-registration
+let autoReclaimedName = false; // true when registeredName was set by autoReclaimDeadSeat() — overridable by explicit register()
 let lastReadOffset = 0; // byte offset into messages.jsonl for efficient polling
 const channelOffsets = new Map(); // per-channel byte offsets for efficient reads
 let heartbeatInterval = null; // heartbeat timer reference
@@ -62,22 +122,14 @@ let messageSeq = 0; // monotonic sequence counter for message ordering
 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 _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
 let budgetResetTime = Date.now(); // resets every 60s
 let _channelSendTimes = {}; // per-channel rate limit sliding window
 
-// --- Read cache (eliminates 70%+ redundant disk I/O) ---
-const _cache = {};
-function cachedRead(key, readFn, ttlMs = 2000) {
-  const now = Date.now();
-  const entry = _cache[key];
-  if (entry && now - entry.ts < ttlMs) return entry.val;
-  const val = readFn();
-  _cache[key] = { val, ts: now };
-  return val;
-}
-function invalidateCache(key) { delete _cache[key]; }
+// cachedRead, invalidateCache imported from lib/file-io.js
 
 // --- Group conversation mode ---
 const CONFIG_FILE = path.join(DATA_DIR, 'config.json');
@@ -87,20 +139,7 @@ function getConfig() {
   try { return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')); } catch { return {}; }
 }
 
-// File-based lock for config.json (prevents managed state race conditions)
-const CONFIG_LOCK = CONFIG_FILE + '.lock';
-function lockConfigFile() {
-  const maxWait = 5000; const start = Date.now();
-  while (Date.now() - start < maxWait) {
-    try { fs.writeFileSync(CONFIG_LOCK, String(process.pid), { flag: 'wx' }); return true; }
-    catch { /* lock exists, wait */ }
-    const wait = Date.now(); while (Date.now() - wait < 50) {} // busy-wait 50ms
-  }
-  try { fs.unlinkSync(CONFIG_LOCK); } catch {}
-  try { fs.writeFileSync(CONFIG_LOCK, String(process.pid), { flag: 'wx' }); return true; } catch {}
-  return false;
-}
-function unlockConfigFile() { try { fs.unlinkSync(CONFIG_LOCK); } catch {} }
+// lockConfigFile, unlockConfigFile imported from lib/file-io.js
 
 function saveConfig(config) {
   ensureDataDir();
@@ -242,7 +281,7 @@ function migrateIfNeeded() {
     if (fs.existsSync(DATA_VERSION_FILE)) {
       dataVersion = parseInt(fs.readFileSync(DATA_VERSION_FILE, 'utf8').trim()) || 0;
     }
-  } catch {}
+  } catch (e) { log.debug("data version read failed:", e.message); }
   if (dataVersion >= CURRENT_DATA_VERSION) return;
 
   // Run migrations in order
@@ -251,10 +290,10 @@ function migrateIfNeeded() {
   // if (dataVersion < 2) { /* migrate v1 → v2 */ }
 
   // Stamp current version
-  try { fs.writeFileSync(DATA_VERSION_FILE, String(CURRENT_DATA_VERSION)); } catch {}
+  try { fs.writeFileSync(DATA_VERSION_FILE, String(CURRENT_DATA_VERSION)); } catch (e) { log.warn('Failed to write data version:', e.message); }
 }
 
-const RESERVED_NAMES = ['__system__', '__all__', '__open__', '__close__', 'system', 'dashboard', 'Dashboard'];
+const RESERVED_NAMES = ['__system__', '__all__', '__open__', '__close__', '__user__', 'system', 'dashboard', 'Dashboard'];
 
 function sanitizeName(name) {
   if (typeof name !== 'string' || !/^[a-zA-Z0-9_-]{1,20}$/.test(name)) {
@@ -307,102 +346,12 @@ function trimConsumedIds(agentName, ids) {
     for (const id of ids) {
       if (!currentIds.has(id)) ids.delete(id);
     }
-  } catch {}
-}
-
-function readJsonl(file) {
-  if (!fs.existsSync(file)) return [];
-  const content = fs.readFileSync(file, 'utf8').trim();
-  if (!content) return [];
-  return content.split(/\r?\n/).map(line => {
-    try { return JSON.parse(line); } catch { return null; }
-  }).filter(Boolean);
+  } catch (e) { log.debug("consumed ID trim failed:", e.message); }
 }
 
-// Optimized: read only NEW lines from a JSONL file starting at byte offset
-// Returns { messages, newOffset } — caller tracks offset between calls
-function readJsonlFromOffset(file, offset) {
-  if (!fs.existsSync(file)) return { messages: [], newOffset: 0 };
-  const stat = fs.statSync(file);
-  if (stat.size <= offset) return { messages: [], newOffset: offset };
-  const fd = fs.openSync(file, 'r');
-  const buf = Buffer.alloc(stat.size - offset);
-  fs.readSync(fd, buf, 0, buf.length, offset);
-  fs.closeSync(fd);
-  const content = buf.toString('utf8').trim();
-  if (!content) return { messages: [], newOffset: stat.size };
-  const messages = content.split(/\r?\n/).map(line => {
-    try { return JSON.parse(line); } catch { return null; }
-  }).filter(Boolean);
-  return { messages, newOffset: stat.size };
-}
+// readJsonl, readJsonlFromOffset, tailReadJsonl imported from lib/file-io.js
 
-// Scale fix: read only last N lines of a JSONL file (for history context)
-// Seeks near end of file instead of parsing entire file — O(N) instead of O(all)
-function tailReadJsonl(file, lineCount = 100) {
-  if (!fs.existsSync(file)) return [];
-  const stat = fs.statSync(file);
-  if (stat.size === 0) return [];
-  // Estimate ~300 bytes per line, read enough from the end
-  const readSize = Math.min(stat.size, lineCount * 300);
-  const offset = Math.max(0, stat.size - readSize);
-  const fd = fs.openSync(file, 'r');
-  const buf = Buffer.alloc(readSize);
-  fs.readSync(fd, buf, 0, readSize, offset);
-  fs.closeSync(fd);
-  const content = buf.toString('utf8');
-  const lines = content.split(/\r?\n/).filter(l => l.trim());
-  // If we started mid-file, first line may be partial — skip it
-  if (offset > 0 && lines.length > 0) lines.shift();
-  const messages = lines.map(line => {
-    try { return JSON.parse(line); } catch { return null; }
-  }).filter(Boolean);
-  return messages.slice(-lineCount);
-}
-
-// File-based lock for agents.json (prevents registration race conditions)
-const AGENTS_LOCK = AGENTS_FILE + '.lock';
-function lockAgentsFile() {
-  const maxWait = 5000; const start = Date.now();
-  let backoff = 1; // exponential backoff: 1ms → 2ms → 4ms → ... → 500ms max
-  while (Date.now() - start < maxWait) {
-    try { fs.writeFileSync(AGENTS_LOCK, String(process.pid), { flag: 'wx' }); return true; }
-    catch { /* lock exists, wait with exponential backoff */ }
-    const wait = Date.now(); while (Date.now() - wait < backoff) {}
-    backoff = Math.min(backoff * 2, 500);
-  }
-  // Force-break stale lock after timeout
-  try { fs.unlinkSync(AGENTS_LOCK); } catch {}
-  try { fs.writeFileSync(AGENTS_LOCK, String(process.pid), { flag: 'wx' }); return true; } catch {}
-  return false;
-}
-function unlockAgentsFile() { try { fs.unlinkSync(AGENTS_LOCK); } catch {} }
-
-// Generic file lock for any JSON file (tasks, workflows, channels, etc.)
-function withFileLock(filePath, fn) {
-  const lockPath = filePath + '.lock';
-  const maxWait = 5000; const start = Date.now();
-  let backoff = 1;
-  while (Date.now() - start < maxWait) {
-    try { fs.writeFileSync(lockPath, String(process.pid), { flag: 'wx' }); break; }
-    catch { /* lock exists, wait with exponential backoff */ }
-    const wait = Date.now(); while (Date.now() - wait < backoff) {}
-    backoff = Math.min(backoff * 2, 500);
-    if (Date.now() - start >= maxWait) {
-      // Force-break stale lock — only if holding PID is dead
-      try {
-        const lockPid = parseInt(fs.readFileSync(lockPath, 'utf8').trim(), 10);
-        if (lockPid && lockPid !== process.pid) {
-          try { process.kill(lockPid, 0); /* PID alive — skip, don't corrupt */ return null; } catch { /* PID dead — safe to break */ }
-        }
-      } catch {}
-      try { fs.unlinkSync(lockPath); } catch {}
-      try { fs.writeFileSync(lockPath, String(process.pid), { flag: 'wx' }); } catch { return fn(); }
-      break;
-    }
-  }
-  try { return fn(); } finally { try { fs.unlinkSync(lockPath); } catch {} }
-}
+// lockAgentsFile, unlockAgentsFile, withFileLock imported from lib/file-io.js
 
 function getAgents() {
   return cachedRead('agents', () => {
@@ -418,21 +367,22 @@ function getAgents() {
           try {
             const hb = JSON.parse(fs.readFileSync(path.join(DATA_DIR, f), 'utf8'));
             if (hb.last_activity) agents[name].last_activity = hb.last_activity;
+            if (hb.last_listen_call) agents[name].last_listen_call = hb.last_listen_call;
             if (hb.pid) agents[name].pid = hb.pid;
-          } catch {}
+          } catch (e) { log.debug("heartbeat merge failed:", e.message); }
         }
       }
-    } catch {}
+    } catch (e) { log.debug("heartbeat scan failed:", e.message); }
     return agents;
   }, 1500);
 }
 
 function saveAgents(agents) {
-  // Safe write: serialize first, then write complete string
-  // This minimizes the window where the file could be truncated
   const data = JSON.stringify(agents);
   if (data && data.length > 2) {
     fs.writeFileSync(AGENTS_FILE, data);
+  } else {
+    log.debug('[neohive/agents.json] skipped write (empty {}): ' + AGENTS_FILE);
   }
   invalidateCache('agents');
 }
@@ -440,14 +390,57 @@ function saveAgents(agents) {
 // --- Per-agent heartbeat files (scale fix: eliminates agents.json write contention at 100+ agents) ---
 function heartbeatFile(name) { return path.join(DATA_DIR, `heartbeat-${name}.json`); }
 
-function touchHeartbeat(name) {
+let _lastStdinActivity = null;
+
+function touchHeartbeat(name, isListenCall = false) {
   if (!name) return;
   try {
-    fs.writeFileSync(heartbeatFile(name), JSON.stringify({
-      last_activity: new Date().toISOString(),
+    const now = new Date().toISOString();
+    const target = heartbeatFile(name);
+
+    // Preserve existing last_listen_call so periodic heartbeats don't erase it
+    let prevLastListenCall = null;
+    try {
+      if (fs.existsSync(target)) {
+        const prev = JSON.parse(fs.readFileSync(target, 'utf8'));
+        if (prev.last_listen_call) prevLastListenCall = prev.last_listen_call;
+      }
+    } catch (_) { /* ignore read errors */ }
+
+    const payload = {
+      last_activity: now,
       pid: process.pid,
-    }));
-  } catch {}
+      ppid: process.ppid,
+    };
+    if (isListenCall) {
+      payload.last_listen_call = now;
+    } else if (prevLastListenCall) {
+      payload.last_listen_call = prevLastListenCall;
+    }
+    if (_lastStdinActivity) payload.last_stdin_activity = _lastStdinActivity;
+    if (process.env.CLAUDE_SESSION_ID) payload.claude_session_id = process.env.CLAUDE_SESSION_ID;
+    const tmp = target + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(payload));
+    fs.renameSync(tmp, target);
+  } catch (e) { log.debug("heartbeat write failed:", e.message); }
+}
+
+/**
+ * Passive stdin activity tracker.
+ * Listens for data on process.stdin and timestamps it into the heartbeat file.
+ * Throttled: writes at most once per 2s to avoid disk thrash.
+ */
+let _stdinThrottleTimer = null;
+function startStdinActivityTracker() {
+  if (!process.stdin || !process.stdin.readable) return;
+  process.stdin.on('data', () => {
+    _lastStdinActivity = new Date().toISOString();
+    if (_stdinThrottleTimer || !registeredName) return;
+    _stdinThrottleTimer = setTimeout(() => {
+      _stdinThrottleTimer = null;
+      if (registeredName) touchHeartbeat(registeredName);
+    }, 2000);
+  });
 }
 
 
@@ -466,10 +459,10 @@ function isPidAlive(pid, lastActivity) {
   // Cache with 5s TTL — PID status doesn't change faster than heartbeats
   const cacheKey = `${pid}_${lastActivity}`;
   const cached = _pidAliveCache[cacheKey];
-  if (cached && Date.now() - cached.ts < 5000) return cached.alive;
+  if (cached && Date.now() - cached.ts < SERVER_CONFIG.AGENT_CACHE_TTL_MS) return cached.alive;
 
-  // Faster stale detection in autonomous mode (30s vs 60s) for quicker dead agent recovery
-  const STALE_THRESHOLD = isAutonomousMode() ? 30000 : 60000;
+  // 30s stale threshold — 3x the 10s heartbeat interval, catches dead agents faster
+  const STALE_THRESHOLD = SERVER_CONFIG.AGENT_STALE_THRESHOLD_MS;
   let alive = false;
 
   // PRIORITY 1: Trust heartbeat freshness over PID status
@@ -496,7 +489,7 @@ function isPidAlive(pid, lastActivity) {
   // Evict old entries (keep cache small)
   const keys = Object.keys(_pidAliveCache);
   if (keys.length > 200) {
-    const cutoff = Date.now() - 10000;
+    const cutoff = Date.now() - SERVER_CONFIG.POLL_INTERVAL_MS * 5;
     for (const k of keys) { if (_pidAliveCache[k].ts < cutoff) delete _pidAliveCache[k]; }
   }
   return alive;
@@ -588,6 +581,21 @@ function buildMessageResponse(msg, consumedIds) {
     }
   } catch (e) { log.debug('total message estimate failed:', e.message); }
 
+  // Task nudge: remind agent of their outstanding tasks
+  let taskReminder;
+  try {
+    const myTasks = getTasks().filter(t => t.assignee === registeredName && (t.status === 'pending' || t.status === 'in_progress'));
+    if (myTasks.length > 0) {
+      taskReminder = { pending: myTasks.filter(t => t.status === 'pending').length, in_progress: myTasks.filter(t => t.status === 'in_progress').length, tasks: myTasks.map(t => ({ id: t.id, title: t.title, status: t.status })) };
+    }
+  } catch (e) { log.debug('task reminder in listen failed:', e.message); }
+
+  // Append report-back protocol reminder to all non-system messages
+  const isSystemMsg = msg.from === '__system__' || msg.system === true;
+  const reportBackReminder = isSystemMsg
+    ? undefined
+    : 'When done: send_message() with (1) what you did (2) files changed (3) findings (4) blockers. Then call listen().';
+
   return {
     success: true,
     message: {
@@ -595,11 +603,15 @@ function buildMessageResponse(msg, consumedIds) {
       from: msg.from,
       content: msg.content,
       timestamp: msg.timestamp,
+      priority: classifyPriority(msg),
       ...(msg.reply_to && { reply_to: msg.reply_to }),
       ...(msg.thread_id && { thread_id: msg.thread_id }),
+      ...(reportBackReminder && { _protocol: reportBackReminder }),
     },
     pending_count: pendingCount,
     agents_online: agentsOnline,
+    coordinator_mode: getConfig().coordinator_mode || 'responsive',
+    ...(taskReminder && { task_reminder: taskReminder }),
   };
 }
 
@@ -616,9 +628,11 @@ function autoCompact() {
 
     const messages = lines.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
 
-    // Collect consumed IDs — for __group__ messages, only check ALIVE agents
+    // Collect consumed IDs — for __group__ messages, check ALL registered agents (alive + dead)
+    // This prevents message loss when agents reconnect after a crash
     const agents = getAgents();
-    const aliveAgentNames = Object.keys(agents).filter(n => isPidAlive(agents[n].pid, agents[n].last_activity));
+    const allAgentNames = Object.keys(agents);
+    const retentionMs = (parseInt(process.env.NEOHIVE_RETENTION_HOURS) || SERVER_CONFIG.RETENTION_DEFAULT_HOURS) * 3600000;
     const allConsumed = new Set();
     const perAgentConsumed = {};
     if (fs.existsSync(DATA_DIR)) {
@@ -629,18 +643,24 @@ function autoCompact() {
             const ids = JSON.parse(fs.readFileSync(path.join(DATA_DIR, f), 'utf8'));
             perAgentConsumed[agentName] = new Set(ids);
             ids.forEach(id => allConsumed.add(id));
-          } catch {}
+          } catch (e) { log.debug("consumed ID read failed:", e.message); }
         }
       }
     }
 
     // Keep messages that are NOT fully consumed
-    // For __group__ messages: consumed when ALL ALIVE agents have consumed it (dead agents don't block)
+    // For __group__ messages: consumed when ALL registered agents consumed OR message exceeds retention period
     // For direct messages: consumed when the recipient has consumed it
+    const now = Date.now();
     const active = messages.filter(m => {
       if (m.to === '__group__') {
-        // __group__: check if all alive agents (except sender) have consumed
-        return !aliveAgentNames.every(n => n === m.from || (perAgentConsumed[n] && perAgentConsumed[n].has(m.id)));
+        // Time-based retention: critical messages get 2x retention
+        const msgTime = new Date(m.timestamp).getTime();
+        const msgPriority = classifyPriority(m);
+        const effectiveRetention = msgPriority === 'critical' ? retentionMs * 2 : retentionMs;
+        if (msgTime < Date.now() - effectiveRetention) return false;
+        // Check ALL registered agents (alive + dead) to prevent loss on reconnect
+        return !allAgentNames.every(n => n === m.from || (perAgentConsumed[n] && perAgentConsumed[n].has(m.id)));
       }
       // Direct: standard check
       if (!allConsumed.has(m.id)) return true;
@@ -657,9 +677,23 @@ function autoCompact() {
     }
 
     // Rewrite messages.jsonl atomically — write to temp file then rename
+    // Capture pre-compaction size to detect messages appended during compaction
+    const preCompactSize = Buffer.byteLength(content, 'utf8') + 1; // +1 for trailing newline trimmed earlier
     const newContent = active.map(m => JSON.stringify(m)).join('\n') + (active.length ? '\n' : '');
     const tmpFile = msgFile + '.tmp';
     fs.writeFileSync(tmpFile, newContent);
+    // Check for messages appended after our initial read
+    let lateMessages = '';
+    try {
+      const currentSize = fs.statSync(msgFile).size;
+      if (currentSize > preCompactSize) {
+        const fd = fs.openSync(msgFile, 'r');
+        const lateBuf = Buffer.alloc(currentSize - preCompactSize);
+        fs.readSync(fd, lateBuf, 0, lateBuf.length, preCompactSize);
+        fs.closeSync(fd);
+        lateMessages = lateBuf.toString('utf8');
+      }
+    } catch (e) { log.debug('late message check during compaction:', e.message); }
     try {
       fs.renameSync(tmpFile, msgFile);
     } catch {
@@ -668,7 +702,12 @@ function autoCompact() {
       try { fs.unlinkSync(tmpFile); } catch {}
       return;
     }
-    lastReadOffset = Buffer.byteLength(newContent, 'utf8');
+    // Re-append any messages that arrived during compaction
+    if (lateMessages.trim()) {
+      fs.appendFileSync(msgFile, lateMessages);
+      log.info('Re-appended ' + lateMessages.trim().split('\n').length + ' messages that arrived during compaction');
+    }
+    lastReadOffset = fs.statSync(msgFile).size;
 
     // Trim consumed ID files — keep only IDs still in active messages
     const activeIds = new Set(active.map(m => m.id));
@@ -840,6 +879,21 @@ function saveWorkflows(workflows) {
   });
 }
 
+// Save a checkpoint after a workflow step completes
+function saveWorkflowCheckpoint(wf, step) {
+  if (!wf.checkpoints) wf.checkpoints = [];
+  wf.checkpoints.push({
+    step_id: step.id,
+    step_description: step.description,
+    completed_at: step.completed_at,
+    completed_by: step.assignee || registeredName,
+    output: step.verification || step.notes || null,
+    files_changed: step.files_changed || [],
+    step_states: wf.steps.map(s => ({ id: s.id, status: s.status, assignee: s.assignee || null })),
+  });
+  if (wf.checkpoints.length > 100) wf.checkpoints = wf.checkpoints.slice(-100);
+}
+
 // --- Autonomous mode detection ---
 function isAutonomousMode() {
   const workflows = getWorkflows();
@@ -878,6 +932,25 @@ function findReadySteps(workflow) {
   });
 }
 
+const PLATFORM_SKILLS = {
+  claude:       ['terminal', 'file-editing', 'mcp', 'long-context', 'code-generation'],
+  anthropic:    ['terminal', 'file-editing', 'mcp', 'long-context', 'code-generation'],
+  gemini:       ['terminal', 'file-editing', 'mcp', 'web-search', 'multimodal'],
+  google:       ['terminal', 'file-editing', 'mcp', 'web-search', 'multimodal'],
+  cursor:       ['ide-integrated', 'file-editing', 'mcp', 'code-generation', 'linting'],
+  vscode:       ['ide-integrated', 'file-editing', 'mcp', 'code-completion'],
+  copilot:      ['ide-integrated', 'file-editing', 'mcp', 'code-completion'],
+  antigravity:  ['ide-integrated', 'file-editing', 'mcp', 'agentic'],
+  openai:       ['terminal', 'file-editing', 'sandboxed', 'code-generation'],
+  codex:        ['terminal', 'file-editing', 'sandboxed', 'code-generation'],
+  ollama:       ['local-model', 'offline', 'customizable'],
+};
+
+function getPlatformSkills(provider) {
+  if (!provider || provider === 'unknown') return [];
+  return PLATFORM_SKILLS[provider.toLowerCase()] || ['code-generation', 'file-editing'];
+}
+
 function findUnassignedTasks(skills) {
   const tasks = getTasks();
   // Exclude blocked_permanent tasks and tasks this agent already failed
@@ -897,18 +970,23 @@ function findUnassignedTasks(skills) {
     const words = ((t.title || '') + ' ' + (t.description || '')).toLowerCase().split(/\W+/).filter(w => w.length > 3);
     words.forEach(w => historyKeywords.add(w));
   }
-  // Add explicit skills
+  // Add explicit skills from function param AND agent card
   if (skills) skills.forEach(s => historyKeywords.add(s.toLowerCase()));
+  const cards = readJsonFile(AGENT_CARDS_FILE) || {};
+  const myCard = cards[registeredName];
+  if (myCard && myCard.skills) myCard.skills.forEach(s => historyKeywords.add(s));
+  // Platform skills get half weight (shared across agents, less differentiating)
+  const platformSkillSet = new Set(myCard && myCard.platform_skills ? myCard.platform_skills : []);
 
   // Score each task by affinity (keyword overlap with agent's history + skills)
   // Scale fix: cache task keyword sets to avoid O(N*M) recomputation at 100 agents
   return pending.sort((a, b) => {
     const aKey = 'taskwords_' + a.id;
     const bKey = 'taskwords_' + b.id;
-    const aWords = cachedRead(aKey, () => ((a.title || '') + ' ' + (a.description || '')).toLowerCase().split(/\W+/).filter(w => w.length > 3), 30000);
-    const bWords = cachedRead(bKey, () => ((b.title || '') + ' ' + (b.description || '')).toLowerCase().split(/\W+/).filter(w => w.length > 3), 30000);
-    const aScore = aWords.filter(w => historyKeywords.has(w)).length;
-    const bScore = bWords.filter(w => historyKeywords.has(w)).length;
+    const aWords = cachedRead(aKey, () => ((a.title || '') + ' ' + (a.description || '')).toLowerCase().split(/\W+/).filter(w => w.length > 3), SERVER_CONFIG.WORD_CACHE_TTL_MS);
+    const bWords = cachedRead(bKey, () => ((b.title || '') + ' ' + (b.description || '')).toLowerCase().split(/\W+/).filter(w => w.length > 3), SERVER_CONFIG.WORD_CACHE_TTL_MS);
+    const aScore = aWords.reduce((s, w) => s + (historyKeywords.has(w) ? (platformSkillSet.has(w) ? 0.5 : 1) : 0), 0);
+    const bScore = bWords.reduce((s, w) => s + (historyKeywords.has(w) ? (platformSkillSet.has(w) ? 0.5 : 1) : 0), 0);
     return bScore - aScore;
   });
 }
@@ -952,7 +1030,7 @@ function findStealableWork() {
 function findHelpRequests() {
   // Scale fix: only read last 50 messages — help requests are always recent
   const messages = tailReadJsonl(getMessagesFile(currentBranch), 50);
-  const recentCutoff = Date.now() - 300000;
+  const recentCutoff = Date.now() - SERVER_CONFIG.AUTONOMOUS_LISTEN_MS * 10;
   return messages.filter(m => {
     if (new Date(m.timestamp).getTime() < recentCutoff) return false;
     if (m.from === registeredName) return false;
@@ -1054,12 +1132,14 @@ let _guideCache = { key: null, result: null };
 function buildGuide(level = 'standard') {
   const agents = getAgents();
   const aliveCount = Object.values(agents).filter(a => isPidAlive(a.pid, a.last_activity)).length;
-  const mode = getConfig().conversation_mode || 'direct';
+  const config = getConfig();
+  const mode = config.conversation_mode || 'direct';
+  const coordMode = config.coordinator_mode || 'responsive';
 
   // Cache check: reuse cached guide if nothing changed (saves rebuilding 20-50 rules)
   let rulesMtime = 0;
   try { rulesMtime = fs.existsSync(RULES_FILE) ? fs.statSync(RULES_FILE).mtimeMs : 0; } catch {}
-  const cacheKey = `${level}:${aliveCount}:${mode}:${registeredName}:${rulesMtime}`;
+  const cacheKey = `${level}:${aliveCount}:${mode}:${coordMode}:${registeredName}:${rulesMtime}`;
   if (_guideCache.key === cacheKey && _guideCache.result) return _guideCache.result;
 
   const channels = getChannelsData();
@@ -1072,6 +1152,7 @@ function buildGuide(level = 'standard') {
   const isQualityLead = myRole === 'quality';
   const isMonitor = myRole === 'monitor';
   const isAdvisor = myRole === 'advisor';
+  const isLeadRole = myRole === 'lead' || myRole === 'manager' || myRole === 'coordinator';
   let qualityLeadName = null;
   for (const [pName, prof] of Object.entries(profiles)) {
     if (prof.role && prof.role.toLowerCase() === 'quality' && pName !== registeredName) { qualityLeadName = pName; break; }
@@ -1143,11 +1224,21 @@ function buildGuide(level = 'standard') {
       try {
         const content = fs.readFileSync(guideFile, 'utf8').trim();
         if (content) projectRules = content.split(/\r?\n/).filter(l => l.trim() && !l.startsWith('#')).map(l => l.replace(/^[-*]\s*/, '').trim()).filter(Boolean);
-      } catch {}
-    }
-
-    // Inject dashboard-managed rules into guide
-    const dashboardRules = getRules().filter(r => r.active);
+      } catch (e) { log.debug("guide file read failed:", e.message); }
+    }
+
+    // Inject dashboard-managed rules into guide (filtered by scope)
+    const myProvider = (() => {
+      const ag = getAgents();
+      return ((ag[registeredName] && ag[registeredName].provider) || '').toLowerCase();
+    })();
+    const dashboardRules = getRules().filter(r => {
+      if (!r.active) return false;
+      if (r.scope_role && r.scope_role !== (myRole || '').toLowerCase()) return false;
+      if (r.scope_provider && r.scope_provider !== myProvider) return false;
+      if (r.scope_agent && r.scope_agent !== registeredName) return false;
+      return true;
+    });
     if (dashboardRules.length > 0) {
       for (const r of dashboardRules) {
         rules.push(`[${r.category.toUpperCase()}] ${r.text}`);
@@ -1170,7 +1261,7 @@ function buildGuide(level = 'standard') {
       quality_lead: qualityLeadName || undefined,
       tool_categories: {
         'WORK LOOP': 'get_work, verify_and_advance, retry_with_improvement',
-        'MESSAGING': 'send_message, broadcast, check_messages, get_history, handoff, share_file',
+        'MESSAGING': 'send_message, broadcast, check_messages, consume_messages, get_history, handoff, share_file',
         'COORDINATION': 'get_briefing, log_decision, get_decisions, kb_write, kb_read, kb_list',
         'TASKS': 'create_task, update_task, list_tasks, suggest_task',
         'QUALITY': 'request_review, submit_review',
@@ -1189,6 +1280,17 @@ function buildGuide(level = 'standard') {
     }
   }
 
+  // Lead/Coordinator mode: responsive (stay with human) vs autonomous (run in listen loop)
+  if (isLeadRole && aliveCount >= 2) {
+    const coordinatorMode = getConfig().coordinator_mode || 'responsive';
+    if (coordinatorMode === 'responsive') {
+      rules.push('RESPONSIVE COORDINATOR PATTERN: Use consume_messages() at the start of each interaction to check for agent updates non-blockingly. Process all returned messages, assign work, then return to the human immediately. Do NOT block in listen() — you need to stay responsive to both agents and the user.');
+    } else {
+      rules.push('AUTONOMOUS COORDINATOR PATTERN: Use listen() to wait for agent results. Process responses, delegate follow-up work, and continue the listen loop. Only return to the human when all tasks are complete or when you hit a blocker that requires human input.');
+    }
+    rules.push('CRITICAL: You are a Coordinator. You MUST NOT edit files, write code, or use tools like Edit/Write/Bash for code changes. Your tools are: send_message, create_task, update_task, create_workflow, advance_workflow, workflow_status, list_tasks, consume_messages, broadcast, kb_write, kb_read, log_decision. Delegate ALL code work to other agents.');
+  }
+
   // Tier 0 — THE one rule (always included at every level)
   const listenCmd = isManagedMode() ? 'listen()' : (mode === 'group' ? 'listen_group()' : 'listen()');
   rules.push(`AFTER EVERY ACTION, call ${listenCmd}. This is how you receive messages. NEVER skip this. NEVER use sleep(). NEVER poll with check_messages(). ${listenCmd} is your ONLY way to receive messages.`);
@@ -1247,11 +1349,21 @@ function buildGuide(level = 'standard') {
     try {
       const content = fs.readFileSync(guideFile, 'utf8').trim();
       if (content) projectRules = content.split(/\r?\n/).filter(l => l.trim() && !l.startsWith('#')).map(l => l.replace(/^[-*]\s*/, '').trim()).filter(Boolean);
-    } catch {}
-  }
-
-  // Inject dashboard-managed rules into guide
-  const dashboardRules = getRules().filter(r => r.active);
+    } catch (e) { log.debug("guide file read failed:", e.message); }
+  }
+
+  // Inject dashboard-managed rules into guide (filtered by scope)
+  const agentProvider = (() => {
+    const ag = getAgents();
+    return ((ag[registeredName] && ag[registeredName].provider) || '').toLowerCase();
+  })();
+  const dashboardRules = getRules().filter(r => {
+    if (!r.active) return false;
+    if (r.scope_role && r.scope_role !== myRole) return false;
+    if (r.scope_provider && r.scope_provider !== agentProvider) return false;
+    if (r.scope_agent && r.scope_agent !== registeredName) return false;
+    return true;
+  });
   if (dashboardRules.length > 0) {
     for (const r of dashboardRules) {
       rules.push(`[${r.category.toUpperCase()}] ${r.text}`);
@@ -1266,7 +1378,7 @@ function buildGuide(level = 'standard') {
       ? '1. Call list_agents() to see who is online. 2. Send a message or call listen() to wait.'
       : '1. Call get_briefing() for project context. 2. Call listen_group() to join. 3. Respond and listen_group() again.',
     tool_categories: {
-      'MESSAGING': 'send_message, broadcast, listen_group, listen, check_messages, get_history, get_summary, search_messages, handoff, share_file',
+      'MESSAGING': 'send_message, broadcast, listen_group, listen, check_messages, consume_messages, get_history, get_summary, search_messages, handoff, share_file',
       'COORDINATION': 'get_briefing, log_decision, get_decisions, kb_write, kb_read, kb_list, call_vote, cast_vote, vote_status',
       'TASKS': 'create_task, update_task, list_tasks, declare_dependency, check_dependencies, suggest_task',
       'QUALITY': 'update_progress, get_progress, request_review, submit_review, get_reputation',
@@ -1292,6 +1404,17 @@ function buildGuide(level = 'standard') {
     };
   }
 
+  // Task reminder: show agent's pending/in_progress tasks so they remember to update them
+  if (registeredName) {
+    try {
+      const myTasks = getTasks().filter(t => t.assignee === registeredName && (t.status === 'pending' || t.status === 'in_progress'));
+      if (myTasks.length > 0) {
+        result.your_tasks = myTasks.map(t => ({ id: t.id, title: t.title, status: t.status }));
+        rules.push(`TASK STATUS: You have ${myTasks.length} task(s). Use update_task(task_id, "in_progress") when starting and update_task(task_id, "done") when complete. Your tasks: ${myTasks.map(t => t.id + ' "' + t.title.substring(0, 40) + '" (' + t.status + ')').join('; ')}`);
+      }
+    } catch (e) { log.debug('task reminder in guide failed:', e.message); }
+  }
+
   // Cache the result for subsequent calls with same params
   _guideCache = { key: cacheKey, result };
   return result;
@@ -1299,102 +1422,152 @@ function buildGuide(level = 'standard') {
 
 // --- Tool implementations ---
 
-function toolRegister(name, provider = null) {
+function toolRegister(name, provider = null, skills = null) {
   ensureDataDir();
   migrateIfNeeded(); // run data migrations on first register
   sanitizeName(name);
   lockAgentsFile();
 
   try {
-    const agents = getAgents();
+    const agents = getAgents(true);
     if (agents[name] && agents[name].pid !== process.pid && isPidAlive(agents[name].pid, agents[name].last_activity)) {
       return { error: `Agent "${name}" is already registered by a live process. Choose a different name.` };
     }
 
-    // If name was previously registered by a dead process, verify token to prevent impersonation
-    if (agents[name] && agents[name].token && !isPidAlive(agents[name].pid, agents[name].last_activity)) {
-      // Dead agent — only allow re-registration from the same process (same token)
-      if (registeredToken && registeredToken !== agents[name].token) {
-        return { error: `Agent "${name}" was previously registered by another process. Choose a different name.` };
-      }
+    // Dead agent name reclaim — allow any process to take a dead agent's name
+    if (agents[name] && !isPidAlive(agents[name].pid, agents[name].last_activity)) {
+      log.info(`Agent "${name}" reclaimed (previous PID ${agents[name].pid} is dead)`);
     }
 
     // Prevent re-registration under a different name from the same process
+    // Exception: if registeredName was set by autoReclaimDeadSeat() (not an explicit call), allow override
     if (registeredName && registeredName !== name) {
-      unlockAgentsFile();
-      return { error: `Already registered as "${registeredName}". Cannot change name mid-session.`, current_name: registeredName };
+      if (!autoReclaimedName) {
+        unlockAgentsFile();
+        return { error: `Already registered as "${registeredName}". Cannot change name mid-session.`, current_name: registeredName };
+      }
+      // Auto-reclaimed identity: clean up the old seat before taking the new name
+      const oldName = registeredName;
+      log.info(`Auto-reclaimed seat "${oldName}" overridden by explicit register("${name}")`);
+      // Stop the auto-reclaim heartbeat
+      if (heartbeatInterval) { clearInterval(heartbeatInterval); heartbeatInterval = null; }
+      // Delete the stale heartbeat file for the old agent so it shows as offline
+      try {
+        const oldHbFile = heartbeatFile(oldName);
+        if (fs.existsSync(oldHbFile)) fs.unlinkSync(oldHbFile);
+      } catch (e) { log.debug(`cleanup heartbeat for "${oldName}" failed:`, e.message); }
+      registeredName = null;
+      registeredToken = null;
+      autoReclaimedName = false;
     }
 
     const now = new Date().toISOString();
-    const token = (agents[name] && agents[name].token) || generateToken();
-    agents[name] = { pid: process.pid, timestamp: now, last_activity: now, provider: provider || 'unknown', branch: currentBranch, token, started_at: now };
+    const token = generateToken();
+    const agentEntry = { pid: process.pid, ppid: process.ppid, timestamp: now, last_activity: now, last_listened_at: now, provider: provider || 'unknown', branch: currentBranch, token, started_at: now };
+    if (process.env.CLAUDE_SESSION_ID) agentEntry.claude_session_id = process.env.CLAUDE_SESSION_ID;
+    agents[name] = agentEntry;
     saveAgents(agents);
     registeredName = name;
-  registeredToken = token;
+    registeredToken = token;
+
+    // Auto-create profile if not exists
+    const profiles = getProfiles();
+    if (!profiles[name]) {
+      profiles[name] = { display_name: name, avatar: '', bio: '', role: '', created_at: now };
+      saveProfiles(profiles);
+    }
+
+    // Save agent card with skills (merge platform defaults + explicit)
+    const cards = readJsonFile(AGENT_CARDS_FILE) || {};
+    const explicitSkills = Array.isArray(skills) ? skills.map(s => String(s).toLowerCase().substring(0, 30)).slice(0, 20) : [];
+    const platformSkills = getPlatformSkills(provider);
+    const mergedSkills = [...new Set([...explicitSkills, ...platformSkills])];
+    cards[name] = {
+      name,
+      provider: provider || 'unknown',
+      skills: mergedSkills,
+      platform_skills: platformSkills,
+      registered_at: now,
+    };
+    writeJsonFile(AGENT_CARDS_FILE, cards);
 
-  // Auto-create profile if not exists
-  const profiles = getProfiles();
-  if (!profiles[name]) {
-    profiles[name] = { display_name: name, avatar: '', bio: '', role: '', created_at: now };
-    saveProfiles(profiles);
-  }
+    // Start heartbeat — updates last_activity every 10s so dashboard knows we're alive
+    // Deterministic jitter per agent to spread writes across the interval (prevents lock storms at 10 agents)
+    const heartbeatJitter = name.split('').reduce((h, c) => h + c.charCodeAt(0), 0) % 2000;
+    if (heartbeatInterval) clearInterval(heartbeatInterval);
+    heartbeatInterval = setInterval(() => {
+      try {
+        // Scale fix: write per-agent heartbeat file instead of lock+read+write agents.json
+        // Eliminates write contention — each agent writes only its own file, no locking needed
+        // Pass isListenCall=true when agent is actively in listen() so other agents
+        // see a fresh last_listen_call timestamp and don't send false-positive nudges.
+        touchHeartbeat(registeredName, _isCurrentlyListening);
+        const agents = getAgents(); // cached + merges heartbeat files automatically
+        // Managed mode: detect dead manager and dead turn holder
+        if (isManagedMode()) {
+          const managed = getManagedConfig();
+          let managedChanged = false;
+
+          // Dead manager detection
+          if (managed.manager && managed.manager !== registeredName) {
+            if (agents[managed.manager] && !isPidAlive(agents[managed.manager].pid, agents[managed.manager].last_activity)) {
+              managed.manager = null;
+              managed.floor = 'closed';
+              managed.turn_current = null;
+              managed.turn_queue = [];
+              managedChanged = true;
+              saveManagedConfig(managed);
+              broadcastSystemMessage(`[SYSTEM] Manager disconnected. Call claim_manager() to take over as the new manager.`);
+            }
+          }
 
-  // Start heartbeat — updates last_activity every 10s so dashboard knows we're alive
-  // Deterministic jitter per agent to spread writes across the interval (prevents lock storms at 10 agents)
-  const heartbeatJitter = name.split('').reduce((h, c) => h + c.charCodeAt(0), 0) % 2000;
-  if (heartbeatInterval) clearInterval(heartbeatInterval);
-  heartbeatInterval = setInterval(() => {
-    try {
-      // Scale fix: write per-agent heartbeat file instead of lock+read+write agents.json
-      // Eliminates write contention — each agent writes only its own file, no locking needed
-      touchHeartbeat(registeredName);
-      const agents = getAgents(); // cached + merges heartbeat files automatically
-      // Managed mode: detect dead manager and dead turn holder
-      if (isManagedMode()) {
-        const managed = getManagedConfig();
-        let managedChanged = false;
-
-        // Dead manager detection
-        if (managed.manager && managed.manager !== registeredName) {
-          if (agents[managed.manager] && !isPidAlive(agents[managed.manager].pid, agents[managed.manager].last_activity)) {
-            managed.manager = null;
-            managed.floor = 'closed';
-            managed.turn_current = null;
-            managed.turn_queue = [];
-            managedChanged = true;
-            saveManagedConfig(managed);
-            broadcastSystemMessage(`[SYSTEM] Manager disconnected. Call claim_manager() to take over as the new manager.`);
+          // Dead turn holder detection — unstick the floor
+          if (!managedChanged && managed.turn_current && managed.turn_current !== registeredName && managed.manager) {
+            if (agents[managed.turn_current] && !isPidAlive(agents[managed.turn_current].pid, agents[managed.turn_current].last_activity)) {
+              const deadAgent = managed.turn_current;
+              managed.turn_current = null;
+              managed.floor = 'closed';
+              managed.turn_queue = [];
+              saveManagedConfig(managed);
+              if (managed.manager !== registeredName) {
+                sendSystemMessage(managed.manager, `[FLOOR] ${deadAgent} disconnected while holding the floor. Floor returned to you.`);
+              }
+            }
           }
         }
-
-        // Dead turn holder detection — unstick the floor
-        if (!managedChanged && managed.turn_current && managed.turn_current !== registeredName && managed.manager) {
-          if (agents[managed.turn_current] && !isPidAlive(agents[managed.turn_current].pid, agents[managed.turn_current].last_activity)) {
-            const deadAgent = managed.turn_current;
-            managed.turn_current = null;
-            managed.floor = 'closed';
-            managed.turn_queue = [];
-            saveManagedConfig(managed);
-            if (managed.manager !== registeredName) {
-              sendSystemMessage(managed.manager, `[FLOOR] ${deadAgent} disconnected while holding the floor. Floor returned to you.`);
+        // Clean stale listening_since flags (listen times out at 5min, clear after 6min)
+        for (const [aName, aInfo] of Object.entries(agents)) {
+          if (aInfo.listening_since) {
+            const listenAge = Date.now() - new Date(aInfo.listening_since).getTime();
+            if (listenAge > 360000) {
+              aInfo.listening_since = null;
             }
           }
         }
-      }
-      // Snapshot dead agents BEFORE cleanup (for auto-recovery)
-      snapshotDeadAgents(agents);
-      // Clean up file locks held by dead agents
-      cleanStaleLocks();
-      cleanStaleChannelMembers();
-      // Auto-escalation: notify team about long-blocked tasks
-      escalateBlockedTasks();
-      // Stand-up meetings: periodic team check-ins
-      triggerStandupIfDue();
-      // Watchdog: nudge idle agents, reassign stuck work (autonomous mode only)
-      watchdogCheck();
-    } catch {}
-  }, 10000 + heartbeatJitter);
-  heartbeatInterval.unref(); // Don't prevent process exit
+        // Agent status change notifications — detect agents going offline/online
+        detectAgentStatusChanges(agents);
+        // Auto-nudge system: detect agents that haven't called listen() recently
+        checkListenCompliance(agents);
+        // Snapshot dead agents BEFORE cleanup (for auto-recovery)
+        snapshotDeadAgents(agents);
+        // Clean up file locks held by dead agents
+        cleanStaleLocks();
+        cleanStaleChannelMembers();
+        // Auto-escalation: notify team about long-blocked tasks
+        escalateBlockedTasks();
+        // Stand-up meetings: periodic team check-ins
+        triggerStandupIfDue();
+        // Auto-reassign stuck workflow steps from dead agents
+        checkStuckWorkflowSteps();
+        // Stale task detection: warn about tasks in_progress for >30 minutes without update
+        checkStaleTasks();
+        // Self-healing: silently reclaim tasks from dead agents, poison-pill at retry 3
+        selfHealingWatchdog();
+        // Watchdog: nudge idle agents, reassign stuck work (autonomous mode only)
+        watchdogCheck();
+      } catch (e) { log.warn("heartbeat loop error:", e.message); }
+    }, 10000 + heartbeatJitter);
+    heartbeatInterval.unref(); // Don't prevent process exit
 
     // Fire join event + recovery data for returning agents
     const config = getConfig();
@@ -1456,7 +1629,7 @@ function toolRegister(name, provider = null) {
           // Clean up snapshot after loading
           try { fs.unlinkSync(recoveryFile); } catch {}
         }
-      } catch {}
+      } catch (e) { log.debug("recovery file parse failed:", e.message); }
     }
 
     // Notify other agents
@@ -1470,7 +1643,7 @@ function toolRegister(name, provider = null) {
         if (roleAssignments && roleAssignments[name]) {
           result.your_role = roleAssignments[name];
         }
-      } catch {}
+      } catch (e) { log.debug("role assignment failed:", e.message); }
     }
 
     return result;
@@ -1481,15 +1654,22 @@ function toolRegister(name, provider = null) {
 
 // Update last_activity timestamp for this agent
 // Uses file lock to prevent race with heartbeat writes
-function touchActivity() {
+function touchActivity(isListenCall = false) {
   if (!registeredName) return;
   // Scale fix: write per-agent heartbeat file instead of lock+write agents.json
-  touchHeartbeat(registeredName);
+  touchHeartbeat(registeredName, isListenCall);
 }
 
 // Set or clear the listening_since flag
 function setListening(isListening) {
   if (!registeredName) return;
+  _isCurrentlyListening = !!isListening;
+
+  // Track listen calls in heartbeat for auto-nudge system
+  if (isListening) {
+    touchActivity(true); // Mark as listen call
+  }
+  
   try {
     lockAgentsFile();
     try {
@@ -1502,7 +1682,7 @@ function setListening(isListening) {
         saveAgents(agents);
       }
     } finally { unlockAgentsFile(); }
-  } catch {}
+  } catch (e) { log.debug("register workspace status failed:", e.message); }
 }
 
 function toolListAgents() {
@@ -1513,13 +1693,26 @@ function toolListAgents() {
     const alive = isPidAlive(info.pid, info.last_activity);
     const lastActivity = info.last_activity || info.timestamp;
     const idleSeconds = Math.floor((Date.now() - new Date(lastActivity).getTime()) / 1000);
+    const hasHeartbeat = fs.existsSync(heartbeatFile(name));
     const profile = profiles[name] || {};
+
+    let status;
+    if (alive) {
+      status = (info.listening_since) ? 'listening' : idleSeconds > 30 ? 'idle' : 'working';
+    } else if (!hasHeartbeat) {
+      status = 'unknown';
+    } else if (idleSeconds <= 120) {
+      status = 'stale';
+    } else {
+      status = 'offline';
+    }
+
     result[name] = {
       alive,
       registered_at: info.timestamp,
       last_activity: lastActivity,
       idle_seconds: alive ? idleSeconds : null,
-      status: !alive ? 'dead' : idleSeconds > 60 ? 'sleeping' : 'active',
+      status,
       listening_since: info.listening_since || null,
       is_listening: !!(info.listening_since && alive),
       last_listened_at: info.last_listened_at || null,
@@ -1534,12 +1727,15 @@ function toolListAgents() {
     try {
       const ws = getWorkspace(name);
       if (ws._status) result[name].current_status = ws._status;
-    } catch {}
+    } catch (e) { log.debug("workspace status read failed:", e.message); }
+
+    const ide = readIdeActivity(DATA_DIR, name);
+    if (ide) applyIdeActivityHint(result[name], ide, { dataDir: DATA_DIR, agentName: name });
   }
   return { agents: result };
 }
 
-async function toolSendMessage(content, to = null, reply_to = null, channel = null) {
+async function toolSendMessage(content, to = null, reply_to = null, channel = null, priority = null) {
   if (!registeredName) {
     return { error: 'You must call register() first' };
   }
@@ -1554,7 +1750,8 @@ async function toolSendMessage(content, to = null, reply_to = null, channel = nu
   // Send-after-listen enforcement: must call listen_group between sends in group mode
   // Autonomous mode: relaxed to 5 sends per listen cycle
   const effectiveSendLimit = isAutonomousMode() ? 5 : sendLimit;
-  if (isGroupMode() && sendsSinceLastListen >= effectiveSendLimit) {
+  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.` };
   }
 
@@ -1678,7 +1875,8 @@ async function toolSendMessage(content, to = null, reply_to = null, channel = nu
   const agents = getAgents();
   const otherAgents = Object.keys(agents).filter(n => n !== registeredName);
 
-  if (otherAgents.length === 0) {
+  // Allow sending to __user__ (dashboard human) even when no other agents are registered
+  if (otherAgents.length === 0 && to !== '__user__') {
     return { error: 'No other agents registered' };
   }
 
@@ -1691,7 +1889,8 @@ async function toolSendMessage(content, to = null, reply_to = null, channel = nu
     }
   }
 
-  if (!agents[to]) {
+  // Allow sending to __user__ (human via dashboard) even though they're not a registered agent
+  if (to !== '__user__' && !agents[to]) {
     return { error: `Agent "${to}" is not registered` };
   }
 
@@ -1699,16 +1898,16 @@ async function toolSendMessage(content, to = null, reply_to = null, channel = nu
     return { error: 'Cannot send a message to yourself' };
   }
 
-  // Permission check
-  if (!canSendTo(registeredName, to)) {
+  // Permission check (skip for __user__ — human always has read access)
+  if (to !== '__user__' && !canSendTo(registeredName, to)) {
     return { error: `Permission denied: you are not allowed to send messages to "${to}"` };
   }
 
   const sizeErr = validateContentSize(content);
   if (sizeErr) return sizeErr;
 
-  // Check if recipient is alive — warn if dead
-  const recipientAlive = isPidAlive(agents[to].pid, agents[to].last_activity);
+  // Check if recipient is alive — warn if dead (skip for __user__ — human is always reachable)
+  const recipientAlive = to === '__user__' ? true : isPidAlive(agents[to].pid, agents[to].last_activity);
 
   // Resolve threading — search main messages + channel files
   let thread_id = null;
@@ -1741,6 +1940,7 @@ async function toolSendMessage(content, to = null, reply_to = null, channel = nu
     to: isGroup ? '__group__' : to,
     content,
     timestamp: new Date().toISOString(),
+    ...(priority && ['critical', 'normal', 'low'].includes(priority) && { priority }),
     ...(isGroup && to && { addressed_to: [to] }),
     ...(channel && { channel }),
     ...(reply_to && { reply_to }),
@@ -1829,7 +2029,7 @@ async function toolSendMessage(content, to = null, reply_to = null, channel = nu
           result._decision_hint = `Related decision exists: "${overlap.decision}" (topic: ${overlap.topic || 'general'}). Check get_decisions() before re-debating.`;
         }
       }
-    } catch {}
+    } catch (e) { log.debug("listen channel watcher setup failed:", e.message); }
   }
   if (_cooldownApplied > 0) result.cooldown_applied_ms = _cooldownApplied;
   if (channel) result.channel = channel;
@@ -1846,7 +2046,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 (agents[to] && !agents[to].listening_since) {
+  } 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().`;
   }
 
@@ -1862,6 +2062,25 @@ async function toolSendMessage(content, to = null, reply_to = null, channel = nu
     result.you_have_messages = myPending.length;
     result.urgent = `You have ${myPending.length} unread message(s) waiting. Call listen_group() after this to read them.`;
   }
+
+  // Coordinator enforcement: warn if sending work assignment without creating a task first
+  const senderProfile = getProfiles()[registeredName];
+  const senderRole = senderProfile && senderProfile.role ? senderProfile.role.toLowerCase() : '';
+  const isSenderLead = senderRole === 'lead' || senderRole === 'manager' || senderRole === 'coordinator';
+  if (isSenderLead && to && to !== '__user__' && to !== '__all__' && to !== '__group__') {
+    const assignmentKeywords = /\b(implement|fix|build|add|create|update|redesign|refactor|write|deploy|test|review|research|investigate)\b/i;
+    if (assignmentKeywords.test(content)) {
+      const recentTasks = getTasks().filter(t => {
+        if (t.assignee !== to) return false;
+        const age = Date.now() - new Date(t.created_at).getTime();
+        return age < 60000; // created in last 60 seconds
+      });
+      if (recentTasks.length === 0) {
+        result.task_warning = `No task created for this assignment to ${to}. Use create_task(title, description, "${to}") to formally track this work.`;
+      }
+    }
+  }
+
   return result;
 }
 
@@ -1880,7 +2099,8 @@ function toolBroadcast(content) {
 
   // Send-after-listen enforcement applies to broadcast too
   const effectiveSendLimitBcast = isAutonomousMode() ? 5 : sendLimit;
-  if (isGroupMode() && sendsSinceLastListen >= effectiveSendLimitBcast) {
+  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}).` };
   }
 
@@ -2043,8 +2263,13 @@ function toolCheckMessages(from = null) {
     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,
@@ -2068,6 +2293,60 @@ function toolCheckMessages(from = null) {
   return result;
 }
 
+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',
+  };
+}
+
 function toolAckMessage(messageId) {
   if (!registeredName) {
     return { error: 'You must call register() first' };
@@ -2093,15 +2372,34 @@ function toolAckMessage(messageId) {
 }
 
 // Listen indefinitely — loops wait_for_reply in 5-min chunks until a message arrives
-async function toolListen(from = null) {
+async function toolListen(from = null, outcome = null, task_id = null, summary = null, mode = null) {
   if (!registeredName) {
     return { error: 'You must call register() first' };
   }
 
+  // Mode-based dispatch: explicit mode overrides auto-detection
+  if (mode === 'codex') return toolListenCodex(from, outcome, task_id, summary);
+  if (mode === 'group') return toolListenGroup(outcome, task_id, summary);
+
+  // Outcome validation: update task state before entering the wait loop
+  if (outcome && outcome !== 'in_progress' && task_id) {
+    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() 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().` };
+    }
+    const statusMap = { completed: 'done', blocked: 'blocked', failed: 'blocked_permanent' };
+    const newStatus = statusMap[outcome];
+    if (newStatus) toolUpdateTask(task_id, newStatus, summary || '');
+  }
+
   // Auto-detect group/managed mode and delegate to toolListenGroup
   // This prevents agents from calling the "wrong" listen function
   if (isGroupMode() || isManagedMode()) {
-    return toolListenGroup();
+    return toolListenGroup(null, null, null);
   }
 
   setListening(true);
@@ -2114,9 +2412,13 @@ async function toolListen(from = null) {
     consumed.add(msg.id);
     saveConsumedIds(registeredName, consumed);
     markAsRead(registeredName, msg.id);
-    const _mfL1 = getMessagesFile(currentBranch);
-    if (fs.existsSync(_mfL1)) {
-      lastReadOffset = fs.statSync(_mfL1).size;
+    // Only advance offset to end-of-file if this is the LAST unconsumed message.
+    // Otherwise keep offset so next listen() call re-reads and finds remaining messages.
+    if (existing.length <= 1) {
+      const _mfL1 = getMessagesFile(currentBranch);
+      if (fs.existsSync(_mfL1)) {
+        lastReadOffset = fs.statSync(_mfL1).size;
+      }
     }
     touchActivity();
     setListening(false);
@@ -2152,7 +2454,9 @@ async function toolListen(from = null) {
       const { messages: newMsgs, newOffset } = readNewMessages(lastReadOffset);
       lastReadOffset = newOffset;
       for (const msg of newMsgs) {
-        if (msg.to !== registeredName || consumed.has(msg.id)) continue;
+        if (consumed.has(msg.id)) continue;
+        if (msg.to !== registeredName && msg.to !== '__group__' && msg.to !== '__all__') continue;
+        if (msg.to === '__group__' && msg.from === registeredName) continue;
         if (from && msg.from !== from && !msg.system) continue;
         consumed.add(msg.id);
         saveConsumedIds(registeredName, consumed);
@@ -2198,11 +2502,26 @@ async function toolListen(from = null) {
 
 // Codex-compatible listen — returns after 90s (under Codex's 120s tool timeout)
 // with retry:true so the agent knows to call again immediately
-async function toolListenCodex(from = null) {
+async function toolListenCodex(from = null, outcome = null, task_id = null, summary = null) {
   if (!registeredName) {
     return { error: 'You must call register() first' };
   }
 
+  // Outcome validation: update task state before entering the wait loop
+  if (outcome && outcome !== 'in_progress' && task_id) {
+    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.` };
+    }
+    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().` };
+    }
+    const statusMap = { completed: 'done', blocked: 'blocked', failed: 'blocked_permanent' };
+    const newStatus = statusMap[outcome];
+    if (newStatus) toolUpdateTask(task_id, newStatus, summary || '');
+  }
+
   setListening(true);
 
   // Check existing unconsumed messages first
@@ -2248,7 +2567,9 @@ async function toolListenCodex(from = null) {
       const { messages: newMsgs, newOffset } = readNewMessages(lastReadOffset);
       lastReadOffset = newOffset;
       for (const msg of newMsgs) {
-        if (msg.to !== registeredName || consumed.has(msg.id)) continue;
+        if (consumed.has(msg.id)) continue;
+        if (msg.to !== registeredName && msg.to !== '__group__' && msg.to !== '__all__') continue;
+        if (msg.to === '__group__' && msg.from === registeredName) continue;
         if (from && msg.from !== from && !msg.system) continue;
         consumed.add(msg.id);
         saveConsumedIds(registeredName, consumed);
@@ -2477,12 +2798,27 @@ function hashStagger(name) {
   return 500 + (hash * 137) % 1000; // 0.5-1.5s range
 }
 
-async function toolListenGroup() {
+async function toolListenGroup(outcome = null, task_id = null, summary = null) {
   if (!registeredName) return { error: 'You must call register() first' };
 
+  // Outcome validation: update task state before entering the wait loop
+  if (outcome && outcome !== 'in_progress' && task_id) {
+    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.` };
+    }
+    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().` };
+    }
+    const statusMap = { completed: 'done', blocked: 'blocked', failed: 'blocked_permanent' };
+    const newStatus = statusMap[outcome];
+    if (newStatus) toolUpdateTask(task_id, newStatus, summary || '');
+  }
+
   // Auto-detect direct mode and delegate to toolListen (prevents wrong-function bugs)
   if (!isGroupMode() && !isManagedMode()) {
-    return toolListen();
+    return toolListen(null, null, null, null);
   }
 
   setListening(true);
@@ -2490,7 +2826,7 @@ async function toolListenGroup() {
   const consumed = getConsumedIds(registeredName);
 
   // Autonomous mode: cap listen at 30s — agents should use get_work() instead
-  const autonomousTimeout = isAutonomousMode() ? 30000 : null;
+  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
   const listenStart = Date.now();
 
@@ -2599,7 +2935,7 @@ async function toolListenGroup() {
             });
             chWatcher.on('error', () => {});
             channelWatchers.push(chWatcher);
-          } catch {}
+          } catch (e) { log.debug("channel watcher setup failed:", e.message); }
         }
       }
     } catch {
@@ -2638,6 +2974,72 @@ async function toolListenGroup() {
   });
 }
 
+// Auto speaker selection for group messages — determines who should respond
+// Priority: 1) @mentioned agents, 2) skill match, 3) round-robin fallback
+let _lastSpeakerIndex = 0;
+function selectSpeaker(msg, agentName, aliveAgentNames) {
+  // 1. If explicitly addressed, those agents respond
+  if (msg.addressed_to && msg.addressed_to.length > 0) {
+    return msg.addressed_to.includes(agentName);
+  }
+
+  // 2. Direct messages — always respond
+  if (msg.to === agentName) return true;
+
+  // 3. System messages — everyone sees, nobody needs to respond
+  if (msg.system || msg.from === '__system__') return false;
+
+  // 4. Skill-based matching — check if message content matches agent's skills
+  const cards = readJsonFile(AGENT_CARDS_FILE) || {};
+  const myCard = cards[agentName];
+  if (myCard && myCard.skills && myCard.skills.length > 0 && msg.content) {
+    const contentLower = msg.content.toLowerCase();
+    const hasSkillMatch = myCard.skills.some(skill => contentLower.includes(skill));
+    if (hasSkillMatch) {
+      // Check if OTHER agents also match — if multiple match, pick the best
+      const otherMatchers = aliveAgentNames.filter(n => {
+        if (n === agentName || n === msg.from) return false;
+        const card = cards[n];
+        return card && card.skills && card.skills.some(skill => contentLower.includes(skill));
+      });
+      // If this agent matches and has fewest other matchers, respond
+      if (otherMatchers.length === 0) return true;
+      // Multiple skill matches — first alphabetically gets priority (deterministic)
+      const allMatchers = [agentName, ...otherMatchers].sort();
+      return allMatchers[0] === agentName;
+    }
+  }
+
+  // 5. Round-robin fallback for unaddressed group messages
+  const eligible = aliveAgentNames.filter(n => n !== msg.from).sort();
+  if (eligible.length === 0) return false;
+  const selectedIndex = _lastSpeakerIndex % eligible.length;
+  const selected = eligible[selectedIndex] === agentName;
+  if (selected) _lastSpeakerIndex++;
+  return selected;
+}
+
+// Message priority classification: critical > normal > low
+// Critical: task assignments, human messages, workflow handoffs, system events
+// Normal: regular agent-to-agent chat
+// Low: status updates, acknowledgements
+function classifyPriority(msg) {
+  if (msg.priority) return msg.priority; // explicit priority wins
+  if (msg.from === '__user__') return 'critical';
+  if (msg.system || msg.from === '__system__') {
+    // System events about workflow/task are critical, others are normal
+    if (msg.content && (msg.content.includes('[Workflow') || msg.content.includes('[TASK') || msg.content.includes('[APPROVAL'))) return 'critical';
+    return 'normal';
+  }
+  if (msg.content) {
+    const c = msg.content;
+    if (c.includes('[Workflow') || c.includes('[HANDOFF]') || c.includes('[PLAN')) return 'critical';
+    if (c.startsWith('[STATUS]') || c.startsWith('[ACK]') || c.startsWith('[PROGRESS]')) return 'low';
+  }
+  if (msg.type === 'handoff') return 'critical';
+  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
 function buildListenGroupResponse(batch, consumed, agentName, listenStart) {
@@ -2648,12 +3050,16 @@ function buildListenGroupResponse(batch, consumed, agentName, listenStart) {
   const wasAddressed = batch.some(m => m.addressed_to && m.addressed_to.includes(agentName));
   sendLimit = wasAddressed ? 2 : 1;
 
-  // Sort batch by priority: system > threaded replies > direct > broadcast
+  // Sort batch by priority: critical(0) > normal(1) > low(2), then by type
+  const PRIORITY_ORDER = { critical: 0, normal: 1, low: 2 };
   function messagePriority(m) {
-    if (m.system || m.from === '__system__') return 0;
-    if (m.reply_to || m.thread_id) return 1;
-    if (!m.broadcast) return 2;
-    return 3;
+    const prio = PRIORITY_ORDER[classifyPriority(m)] || 1;
+    // Sub-sort within same priority: system > threaded > direct > broadcast
+    let subPrio = 3;
+    if (m.system || m.from === '__system__') subPrio = 0;
+    else if (m.reply_to || m.thread_id) subPrio = 1;
+    else if (!m.broadcast) subPrio = 2;
+    return prio * 10 + subPrio;
   }
   batch.sort((a, b) => {
     const pa = messagePriority(a), pb = messagePriority(b);
@@ -2686,7 +3092,7 @@ function buildListenGroupResponse(batch, consumed, agentName, listenStart) {
     } else {
       const lastListened = agents[n].last_listened_at;
       const sinceLastListen = lastListened ? Date.now() - new Date(lastListened).getTime() : Infinity;
-      agentStatus[n] = sinceLastListen > 120000 ? 'unresponsive' : 'working';
+      agentStatus[n] = sinceLastListen > SERVER_CONFIG.AGENT_UNRESPONSIVE_MS ? 'unresponsive' : 'working';
     }
   }
 
@@ -2697,6 +3103,7 @@ function buildListenGroupResponse(batch, consumed, agentName, listenStart) {
       return {
         id: m.id, from: m.from, to: m.to, content: m.content,
         timestamp: m.timestamp,
+        priority: classifyPriority(m),
         age_seconds: ageSec,
         ...(ageSec > 30 && { delayed: true }),
         ...(m.reply_to && { reply_to: m.reply_to }),
@@ -2704,7 +3111,7 @@ function buildListenGroupResponse(batch, consumed, agentName, listenStart) {
         ...(m.addressed_to && { addressed_to: m.addressed_to }),
         ...(m.to === '__group__' && {
           addressed_to_you: !m.addressed_to || m.addressed_to.includes(agentName),
-          should_respond: !m.addressed_to || m.addressed_to.includes(agentName),
+          should_respond: selectSpeaker(m, agentName, agentNames),
         }),
       };
     }),
@@ -2744,11 +3151,21 @@ function buildListenGroupResponse(batch, consumed, agentName, listenStart) {
   result.next_action = isAutonomousMode()
     ? 'Process these messages, then call get_work() to continue the proactive work loop. Do NOT call listen_group() — use get_work() instead.'
     : 'After processing these messages and sending your response, call listen_group() again immediately. Never stop listening.';
+  result.coordinator_mode = getConfig().coordinator_mode || 'responsive';
+
+  // Task reminder: remind agent of their outstanding tasks
+  try {
+    const myTasks = getTasks().filter(t => t.assignee === agentName && (t.status === 'pending' || t.status === 'in_progress'));
+    if (myTasks.length > 0) {
+      result.task_reminder = { pending: myTasks.filter(t => t.status === 'pending').length, in_progress: myTasks.filter(t => t.status === 'in_progress').length, tasks: myTasks.map(t => ({ id: t.id, title: t.title, status: t.status })) };
+    }
+  } catch (e) { log.debug('task reminder in listen_group failed:', e.message); }
+
   return result;
 }
 
 function toolGetHistory(limit = 50, thread_id = null) {
-  limit = Math.min(Math.max(1, limit || 50), 500);
+  limit = Math.min(Math.max(1, limit || SERVER_CONFIG.HISTORY_LIMIT_DEFAULT), SERVER_CONFIG.HISTORY_LIMIT_MAX);
   // Tail-read with 2x buffer to account for filtering reducing results
   let history = tailReadJsonl(getHistoryFile(currentBranch), limit * 2);
   if (thread_id) {
@@ -3020,6 +3437,10 @@ function toolCreateTask(title, description = '', assignee = null) {
   saveTasks(tasks);
   touchActivity();
 
+  // Broadcast task creation event
+  const assigneeLabel = task.assignee ? `, assigned to ${task.assignee}` : '';
+  broadcastSystemMessage(`[EVENT] Task "${task.title}" created by ${registeredName}${assigneeLabel}`, registeredName);
+
   const result = { success: true, task_id: task.id, assignee: task.assignee };
   if (taskChannel) result.channel = taskChannel;
   return result;
@@ -3066,9 +3487,52 @@ function toolUpdateTask(taskId, status, notes = null) {
     return { success: true, task_id: task.id, status: 'blocked_permanent', circuit_breaker: true, message: 'Task permanently blocked — too many agents failed. Needs human review.' };
   }
 
+  // Review gate: block 'done' if a quality/reviewer agent is online and no approved review exists
+  if (status === 'done') {
+    const agents = getAgents();
+    const profiles = getProfiles();
+    const hasReviewer = Object.keys(agents).some(n => {
+      if (n === registeredName) return false;
+      if (!isPidAlive(agents[n].pid, agents[n].last_activity)) return false;
+      const role = (profiles[n] && profiles[n].role) || '';
+      return role === 'quality' || role === 'reviewer';
+    });
+    if (hasReviewer) {
+      const reviews = getReviews();
+      const hasApproval = reviews.some(r =>
+        r.status === 'approved' &&
+        r.requested_by === registeredName &&
+        (r.file && task.title && (task.title === r.file || task.title.includes(r.file)))
+      );
+      if (!hasApproval) {
+        const reviewId = 'review_' + generateId();
+        reviews.push({
+          id: reviewId,
+          file: task.title,
+          requested_by: registeredName,
+          status: 'pending',
+          requested_at: new Date().toISOString(),
+        });
+        writeJsonFile(REVIEWS_FILE, reviews);
+        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);
+        logViolation('review_gate_blocked', registeredName, `Task "${task.title}" (${task.id}) blocked — no approved review. Auto-created ${reviewId}.`);
+        touchActivity();
+        return {
+          blocked: true,
+          task_id: task.id,
+          status: 'in_review',
+          review_id: reviewId,
+          message: `Cannot mark done — a reviewer is online and no approval exists. Review ${reviewId} auto-created. Wait for approval, then try again.`,
+        };
+      }
+    }
+  }
+
   task.status = status;
   task.updated_at = new Date().toISOString();
-  // Clear escalation flag when task is unblocked
   if (status !== 'blocked' && task.escalated_at) delete task.escalated_at;
   if (notes) {
     task.notes.push({ by: registeredName, text: notes, at: new Date().toISOString() });
@@ -3086,7 +3550,7 @@ function toolUpdateTask(taskId, status, notes = null) {
     } else if (status === 'blocked') {
       saveWorkspace(registeredName, Object.assign(getWorkspace(registeredName), { _status: `BLOCKED on: ${task.title}`, _status_since: new Date().toISOString() }));
     }
-  } catch {}
+  } catch (e) { log.warn("verify_and_advance failed:", e.message); }
 
   // Task-channel auto-join: when claiming a task that has a channel, auto-join it
   if (status === 'in_progress' && task.channel) {
@@ -3100,6 +3564,7 @@ function toolUpdateTask(taskId, status, notes = null) {
   // Event hooks: task completion
   if (status === 'done') {
     fireEvent('task_complete', { title: task.title, created_by: task.created_by });
+    appendNotification('task_done', registeredName, `Task "${task.title}" completed by ${registeredName}`, task.id);
     // Check if this resolves any dependencies
     const deps = getDeps();
     for (const dep of deps) {
@@ -3128,6 +3593,50 @@ function toolUpdateTask(taskId, status, notes = null) {
     if (aliveOthers.length > 0) {
       broadcastSystemMessage(`[REVIEW NEEDED] ${registeredName} completed task "${task.title}". Team: please review the work and call submit_review() if applicable.`, registeredName);
     }
+
+    // Auto-sync: advance matching workflow step when task is done
+    try {
+      const workflows = getWorkflows();
+      let wfChanged = false;
+      for (const wf of workflows) {
+        if (wf.status !== 'active') continue;
+        for (const step of wf.steps) {
+          if (step.status !== 'in_progress') continue;
+          if (step.assignee !== registeredName) continue;
+          // Match by assignee — the agent who completed the task also has an in_progress step
+          step.status = 'done';
+          step.completed_at = new Date().toISOString();
+          step.notes = `Auto-completed via task "${task.title}"`;
+          saveWorkflowCheckpoint(wf, step);
+          // Start next ready steps
+          const nextSteps = findReadySteps(wf);
+          for (const ns of nextSteps) {
+            if (ns.requires_approval) {
+              ns.status = 'awaiting_approval';
+              ns.approval_requested_at = new Date().toISOString();
+              sendSystemMessage('__user__', `[APPROVAL NEEDED] Workflow "${wf.name}" — Step ${ns.id}: "${ns.description}". Approve or reject from the dashboard.`);
+            } else {
+              ns.status = 'in_progress';
+              ns.started_at = new Date().toISOString();
+              if (ns.assignee && ns.assignee !== registeredName) {
+                const handoffContent = `[Workflow "${wf.name}"] Step ${ns.id} assigned to you: ${ns.description}`;
+                messageSeq++;
+                const hMsg = { id: generateId(), seq: messageSeq, from: registeredName, to: ns.assignee, content: handoffContent, timestamp: new Date().toISOString(), type: 'handoff' };
+                fs.appendFileSync(getMessagesFile(currentBranch), JSON.stringify(hMsg) + '\n');
+                fs.appendFileSync(getHistoryFile(currentBranch), JSON.stringify(hMsg) + '\n');
+              }
+            }
+          }
+          if (wf.steps.every(s => s.status === 'done')) wf.status = 'completed';
+          wf.updated_at = new Date().toISOString();
+          wfChanged = true;
+          broadcastSystemMessage(`[WORKFLOW] Step "${step.description}" auto-advanced via task completion by ${registeredName}`);
+          break; // one step per task completion
+        }
+        if (wfChanged) break;
+      }
+      if (wfChanged) saveWorkflows(workflows);
+    } catch (e) { log.warn('auto-advance workflow on task done failed:', e.message); }
   }
 
   return { success: true, task_id: task.id, status: task.status, title: task.title };
@@ -3149,7 +3658,7 @@ function toolListTasks(status = null, assignee = null) {
       created_by: t.created_by,
       created_at: t.created_at,
       updated_at: t.updated_at,
-      notes_count: t.notes.length,
+      notes_count: Array.isArray(t.notes) ? t.notes.length : 0,
     })),
   };
 }
@@ -3203,7 +3712,7 @@ function toolSearchMessages(query, from = null, limit = 20) {
         allMessages = allMessages.concat(chMsgs);
       }
     }
-  } catch {}
+  } catch (e) { log.warn("get_work search failed:", e.message); }
   // Sort by timestamp descending for newest-first results
   allMessages.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
 
@@ -3233,7 +3742,7 @@ function toolSearchMessages(query, from = null, limit = 20) {
           allMessages = allMessages.concat(readJsonl(chFile));
         }
       }
-    } catch {}
+    } catch (e) { log.debug("get_work detail failed:", e.message); }
     allMessages.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
     for (let i = 0; i < allMessages.length && results.length < limit; i++) {
       const m = allMessages[i];
@@ -3411,7 +3920,8 @@ function toolCreateWorkflow(name, steps, autonomous = false, parallel = false) {
       description: step.description.substring(0, 200),
       assignee: step.assignee || null,
       depends_on: Array.isArray(step.depends_on) ? step.depends_on : [],
-      status: 'pending', // all start pending; we'll activate ready ones below
+      requires_approval: !!step.requires_approval,
+      status: 'pending',
       started_at: null,
       completed_at: null,
       notes: '',
@@ -3500,11 +4010,37 @@ function toolAdvanceWorkflow(workflowId, notes) {
   currentStep.completed_at = new Date().toISOString();
   if (notes) currentStep.notes = notes.substring(0, 500);
 
+  // Save checkpoint
+  saveWorkflowCheckpoint(wf, currentStep);
+
+  // Auto-sync: mark matching in_progress tasks as done
+  try {
+    const tasks = getTasks();
+    const matchingTask = tasks.find(t =>
+      t.status === 'in_progress' && t.assignee === registeredName
+    );
+    if (matchingTask) {
+      matchingTask.status = 'done';
+      matchingTask.updated_at = new Date().toISOString();
+      matchingTask.notes.push({ by: '__system__', text: `Auto-completed via workflow step "${currentStep.description}"`, at: new Date().toISOString() });
+      saveTasks(tasks);
+    }
+  } catch (e) { log.warn('auto-complete task on workflow advance failed:', e.message); }
+
   // Find all ready steps (supports parallel via depends_on)
   const nextSteps = findReadySteps(wf);
   if (nextSteps.length > 0) {
     const agents = getAgents();
     for (const step of nextSteps) {
+      // Check if step requires human approval before starting
+      if (step.requires_approval) {
+        step.status = 'awaiting_approval';
+        step.approval_requested_at = new Date().toISOString();
+        sendSystemMessage('__user__',
+          `[APPROVAL NEEDED] Workflow "${wf.name}" — Step ${step.id}: "${step.description}". Approve or reject from the dashboard.`
+        );
+        continue;
+      }
       step.status = 'in_progress';
       step.started_at = new Date().toISOString();
       if (step.assignee && agents[step.assignee] && step.assignee !== registeredName && canSendTo(registeredName, step.assignee)) {
@@ -3524,6 +4060,7 @@ function toolAdvanceWorkflow(workflowId, notes) {
 
   const doneCount = wf.steps.filter(s => s.status === 'done').length;
   const pct = Math.round((doneCount / wf.steps.length) * 100);
+  appendNotification('workflow_advanced', registeredName, `Workflow "${wf.name}" step ${currentStep.id} done (${pct}%)`, wf.id);
 
   return {
     success: true,
@@ -3535,14 +4072,32 @@ function toolAdvanceWorkflow(workflowId, notes) {
   };
 }
 
-function toolWorkflowStatus(workflowId) {
+function toolWorkflowStatus(workflowId, action, checkpointIndex) {
   const workflows = getWorkflows();
+
+  // Rollback action
+  if (action === 'rollback' && workflowId && checkpointIndex !== undefined) {
+    const wf = workflows.find(w => w.id === workflowId);
+    if (!wf) return { error: `Workflow not found: ${workflowId}` };
+    if (!wf.checkpoints || !wf.checkpoints[checkpointIndex]) return { error: 'Checkpoint not found' };
+    const checkpoint = wf.checkpoints[checkpointIndex];
+    for (const savedStep of checkpoint.step_states) {
+      const step = wf.steps.find(s => s.id === savedStep.id);
+      if (step) { step.status = savedStep.status; step.assignee = savedStep.assignee; }
+    }
+    wf.updated_at = new Date().toISOString();
+    saveWorkflows(workflows);
+    broadcastSystemMessage(`[WORKFLOW] Rolled back "${wf.name}" to checkpoint: step "${checkpoint.step_description}"`);
+    return { success: true, rolled_back_to: checkpoint };
+  }
+
   if (workflowId) {
     const wf = workflows.find(w => w.id === workflowId);
     if (!wf) return { error: `Workflow not found: ${workflowId}` };
     const doneCount = wf.steps.filter(s => s.status === 'done').length;
     const pct = Math.round((doneCount / wf.steps.length) * 100);
     const result = { workflow: wf, progress: `${doneCount}/${wf.steps.length} (${pct}%)` };
+    if (wf.checkpoints) result.checkpoints = wf.checkpoints.length;
     if (wf.status === 'completed') result.report = generateCompletionReport(wf);
     return result;
   }
@@ -3550,7 +4105,7 @@ function toolWorkflowStatus(workflowId) {
     count: workflows.length,
     workflows: workflows.map(w => {
       const doneCount = w.steps.filter(s => s.status === 'done').length;
-      return { id: w.id, name: w.name, status: w.status, steps: w.steps.length, done: doneCount, progress: Math.round((doneCount / w.steps.length) * 100) + '%' };
+      return { id: w.id, name: w.name, status: w.status, steps: w.steps.length, done: doneCount, progress: Math.round((doneCount / w.steps.length) * 100) + '%', checkpoints: w.checkpoints ? w.checkpoints.length : 0 };
     }),
   };
 }
@@ -3880,7 +4435,8 @@ async function toolVerifyAndAdvance(params) {
     // AUTO-ADVANCE
     currentStep.status = 'done';
     currentStep.completed_at = new Date().toISOString();
-    clearCheckpoint(registeredName, workflow_id, currentStep.id); // Item 8: clear checkpoint on completion
+    saveWorkflowCheckpoint(wf, currentStep);
+    clearCheckpoint(registeredName, workflow_id, currentStep.id);
     return advanceToNextSteps(false);
   }
 
@@ -3888,6 +4444,7 @@ async function toolVerifyAndAdvance(params) {
     // ADVANCE BUT FLAG
     currentStep.status = 'done';
     currentStep.completed_at = new Date().toISOString();
+    saveWorkflowCheckpoint(wf, currentStep);
     currentStep.flagged = true;
     currentStep.flag_reason = `Low confidence (${confidence}%). May need review later.`;
     clearCheckpoint(registeredName, workflow_id, currentStep.id); // Item 8: clear checkpoint
@@ -4057,51 +4614,192 @@ function reassignWorkFrom(deadAgentName) {
   return reassignCount;
 }
 
-function watchdogCheck() {
-  // Run in autonomous mode always, AND in group mode when agents are idle 5+ min
-  if (!isAutonomousMode() && !isGroupMode()) return;
-  if (!amIWatchdog()) return;
-
+// Auto-reassign workflow steps from dead agents after timeout
+function checkStuckWorkflowSteps() {
+  if (!registeredName) return;
+  const workflows = getWorkflows();
   const agents = getAgents();
-  const now = Date.now();
-  let agentsChanged = false;
-
-  for (const [name, agent] of Object.entries(agents)) {
-    if (name === registeredName) continue;
-    if (!isPidAlive(agent.pid, agent.last_activity)) continue;
+  const timeoutMs = (parseInt(process.env.NEOHIVE_STEP_TIMEOUT_MINUTES) || 5) * 60000;
+  let changed = false;
 
-    const idleTime = now - new Date(agent.last_activity).getTime();
+  for (const wf of workflows) {
+    if (wf.status !== 'active') continue;
+    if (wf.paused) continue;
 
-    // IDLE > 2 minutes: nudge
-    if (idleTime > 120000 && !agent.watchdog_nudged) {
-      sendSystemMessage(name,
-        `[WATCHDOG] You've been idle for ${Math.round(idleTime / 60000)} minutes. Call get_work() to find your next task. Never be idle.`
-      );
-      trackReputation(name, 'watchdog_nudge');
-      agent.watchdog_nudged = now;
-      agentsChanged = true;
-    }
+    for (const step of wf.steps) {
+      if (step.status !== 'in_progress') continue;
+      if (!step.assignee) continue;
+      if (!step.started_at) continue;
+
+      const elapsed = Date.now() - new Date(step.started_at).getTime();
+      if (elapsed < timeoutMs) continue;
+
+      const agentInfo = agents[step.assignee];
+      if (agentInfo && isPidAlive(agentInfo.pid, agentInfo.last_activity)) continue;
+
+      log.warn(`Workflow step ${step.id} reassigned: ${step.assignee} offline for ${Math.round(elapsed / 60000)}min`);
+      const deadAgent = step.assignee;
+      step.status = 'pending';
+      step.assignee = null;
+      step.reassigned_from = deadAgent;
+      step.reassigned_at = new Date().toISOString();
+      changed = true;
 
-    // IDLE > 5 minutes: stronger nudge
-    if (idleTime > 300000 && !agent.watchdog_hard_nudged) {
-      sendSystemMessage(name,
-        `[WATCHDOG] You've been idle for ${Math.round(idleTime / 60000)} minutes. Call get_work() NOW or your work will be reassigned.`
+      broadcastSystemMessage(
+        `[WORKFLOW] Step "${step.description}" reassigned — ${deadAgent} went offline. Next available agent will pick it up via get_work().`
       );
-      agent.watchdog_hard_nudged = now;
-      agentsChanged = true;
-    }
-
-    // IDLE > 10 minutes: reassign their work
-    if (idleTime > 600000 && !agent.watchdog_reassigned) {
-      const count = reassignWorkFrom(name);
-      broadcastSystemMessage(`[WATCHDOG] ${name} has been unresponsive for 10+ minutes. ${count} task(s) reassigned.`);
-      agent.watchdog_reassigned = now;
-      agentsChanged = true;
     }
   }
 
-  // Check for stuck workflow steps
-  const workflows = getWorkflows();
+  if (changed) saveWorkflows(workflows);
+}
+
+// Stale task detection: warn about tasks in_progress for >30 minutes without update
+const _staleTaskWarned = new Set();
+function checkStaleTasks() {
+  try {
+    const tasks = getTasks();
+    const staleThresholdMs = 30 * 60 * 1000; // 30 minutes
+    const now = Date.now();
+    for (const task of tasks) {
+      if (task.status !== 'in_progress') continue;
+      if (!task.updated_at) continue;
+      const elapsed = now - new Date(task.updated_at).getTime();
+      if (elapsed < staleThresholdMs) continue;
+      if (_staleTaskWarned.has(task.id)) continue;
+      _staleTaskWarned.add(task.id);
+      const mins = Math.round(elapsed / 60000);
+      broadcastSystemMessage(`[WARNING] Stale task: "${task.title}" assigned to ${task.assignee || 'unassigned'} — in_progress for ${mins}min without update. Agent should call update_task("${task.id}", "done") or report a blocker.`);
+      log.warn(`Stale task detected: ${task.id} "${task.title}" (${mins}min)`);
+    }
+  } catch (e) { log.debug('stale task check failed:', e.message); }
+}
+
+// Self-healing watchdog: silently reclaim stale in_progress tasks from dead/idle agents.
+// Runs at most once per 60s (throttled inside the 10s heartbeat loop).
+// retry_count < 3 → strip assignee + reset to pending (next agent picks it up via get_work)
+// retry_count >= 3 → mark blocked_permanent + wake coordinator
+let _lastSelfHealRun = 0;
+function selfHealingWatchdog() {
+  const now = Date.now();
+  if (now - _lastSelfHealRun < 60000) return;
+  _lastSelfHealRun = now;
+
+  try {
+    const tasks = getTasks();
+    const agents = getAgents();
+    const IDLE_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
+    const POISON_PILL_COUNT = 3;
+
+    let changed = false;
+    const reclaimed = [];
+    const poisoned = [];
+
+    for (const task of tasks) {
+      if (task.status !== 'in_progress') continue;
+      if (!task.assignee) continue;
+
+      const assignee = agents[task.assignee];
+      // Only reclaim if the assignee is definitively dead (PID gone + heartbeat stale)
+      if (assignee && isPidAlive(assignee.pid, assignee.last_activity)) continue;
+      // Also reclaim if assignee entry missing entirely (agent never re-registered)
+      const lastActivity = assignee ? new Date(assignee.last_activity).getTime() : 0;
+      if (assignee && (now - lastActivity) < IDLE_THRESHOLD_MS) continue;
+
+      const retryCount = (task.retry_count || 0) + 1;
+      task.retry_count = retryCount;
+      task.updated_at = new Date().toISOString();
+
+      if (retryCount >= POISON_PILL_COUNT) {
+        // Poison pill: task has been abandoned too many times — escalate
+        task.status = 'blocked_permanent';
+        task.blocked_reason = `Abandoned ${retryCount} times by agents (last: ${task.assignee}). Needs coordinator intervention.`;
+        task.assignee = null;
+        poisoned.push(task);
+      } else {
+        // Normal self-heal: reset to pending for next available agent
+        const prevAssignee = task.assignee;
+        task.assignee = null;
+        task.status = 'pending';
+        reclaimed.push({ task, prevAssignee });
+      }
+      changed = true;
+    }
+
+    if (!changed) return;
+    saveTasks(tasks);
+
+    // Notify team about reclaimed tasks (one broadcast)
+    if (reclaimed.length > 0) {
+      const names = reclaimed.map(r => `"${r.task.title}" (was: ${r.prevAssignee})`).join(', ');
+      broadcastSystemMessage(`[WATCHDOG] ${reclaimed.length} stale task(s) reset to pending: ${names}. Call get_work() to claim.`);
+      log.info(`[self-heal] Reclaimed ${reclaimed.length} task(s): ${reclaimed.map(r => r.task.id).join(', ')}`);
+    }
+
+    // Wake coordinator for poison-pill tasks
+    if (poisoned.length > 0) {
+      const profiles = readJsonFileSafe(PROFILES_FILE, {});
+      const lead = Object.entries(agents).find(([n, a]) =>
+        isPidAlive(a.pid, a.last_activity) && profiles[n] && (profiles[n].role === 'lead' || profiles[n].role === 'coordinator')
+      );
+      const leadName = lead ? lead[0] : null;
+      const taskList = poisoned.map(t => `"${t.title}" (${t.id})`).join(', ');
+      const msg = `[WATCHDOG] POISON PILL: ${poisoned.length} task(s) abandoned ${POISON_PILL_COUNT}+ times and marked blocked_permanent: ${taskList}. Manual intervention required.`;
+      if (leadName) {
+        sendSystemMessage(leadName, msg);
+      } else {
+        broadcastSystemMessage(msg);
+      }
+      log.warn(`[self-heal] Poison pill tasks: ${poisoned.map(t => t.id).join(', ')}`);
+    }
+  } catch (e) { log.warn('[self-heal] watchdog error:', e.message); }
+}
+
+function watchdogCheck() {
+  // Run in autonomous mode always, AND in group mode when agents are idle 5+ min
+  if (!isAutonomousMode() && !isGroupMode()) return;
+  if (!amIWatchdog()) return;
+
+  const agents = getAgents();
+  const now = Date.now();
+  let agentsChanged = false;
+
+  for (const [name, agent] of Object.entries(agents)) {
+    if (name === registeredName) continue;
+    if (!isPidAlive(agent.pid, agent.last_activity)) continue;
+
+    const idleTime = now - new Date(agent.last_activity).getTime();
+
+    // IDLE > 2 minutes: nudge
+    if (idleTime > 120000 && !agent.watchdog_nudged) {
+      sendSystemMessage(name,
+        `[WATCHDOG] You've been idle for ${Math.round(idleTime / 60000)} minutes. Call get_work() to find your next task. Never be idle.`
+      );
+      trackReputation(name, 'watchdog_nudge');
+      agent.watchdog_nudged = now;
+      agentsChanged = true;
+    }
+
+    // IDLE > 5 minutes: stronger nudge
+    if (idleTime > 300000 && !agent.watchdog_hard_nudged) {
+      sendSystemMessage(name,
+        `[WATCHDOG] You've been idle for ${Math.round(idleTime / 60000)} minutes. Call get_work() NOW or your work will be reassigned.`
+      );
+      agent.watchdog_hard_nudged = now;
+      agentsChanged = true;
+    }
+
+    // IDLE > 10 minutes: reassign their work
+    if (idleTime > 600000 && !agent.watchdog_reassigned) {
+      const count = reassignWorkFrom(name);
+      broadcastSystemMessage(`[WATCHDOG] ${name} has been unresponsive for 10+ minutes. ${count} task(s) reassigned.`);
+      agent.watchdog_reassigned = now;
+      agentsChanged = true;
+    }
+  }
+
+  // Check for stuck workflow steps
+  const workflows = getWorkflows();
   let workflowsChanged = false;
   for (const wf of workflows) {
     if (wf.status !== 'active') continue;
@@ -4160,7 +4858,7 @@ function watchdogCheck() {
         sendSystemMessage(worker, `[REBALANCE] You've been moved from ${quietTeam.name} to ${busyTeam.name} — they have ${busyTeam.pendingTasks} pending tasks and need help.`);
       }
     }
-  } catch {}
+  } catch (e) { log.warn("escalate blocked tasks failed:", e.message); }
 
   // UE5 safety: detect stale UE5 locks (ue5-editor, ue5-compile)
   try {
@@ -4185,7 +4883,7 @@ function watchdogCheck() {
       }
     }
     if (locksChanged) writeJsonFile(LOCKS_FILE, locks);
-  } catch {}
+  } catch (e) { log.warn("stale lock cleanup failed:", e.message); }
 
   if (agentsChanged) saveAgents(agents);
   if (workflowsChanged) saveWorkflows(workflows);
@@ -4407,7 +5105,7 @@ function generateCompletionReport(workflow) {
         totalRetries += relevant.length;
         for (const r of relevant) retryDetails.push({ agent: name, task: r.task, attempt: r.attempt });
       }
-    } catch {}
+    } catch (e) { log.debug("auto-plan retry scan failed:", e.message); }
   }
 
   const report = {
@@ -4585,7 +5283,7 @@ function autoAssignRoles() {
         }
       }
       saveChannelsData(channels);
-    } catch {}
+    } catch (e) { log.warn("stale channel cleanup failed:", e.message); }
   }
 
   return assignments;
@@ -4941,7 +5639,7 @@ function toolForkConversation(fromMessageId, branchName) {
         saveAgents(agents);
       }
     } finally { unlockAgentsFile(); }
-  } catch {}
+  } catch (e) { log.warn("auto role rebalance failed:", e.message); }
 
   return { success: true, branch: branchName, forked_from: branches[branchName].forked_from, messages_copied: forkedHistory.length };
 }
@@ -4965,7 +5663,7 @@ function toolSwitchBranch(branchName) {
         saveAgents(agents);
       }
     } finally { unlockAgentsFile(); }
-  } catch {}
+  } catch (e) { log.warn("quality lead failover failed:", e.message); }
 
   return { success: true, branch: branchName, message: `Switched to branch "${branchName}". Read offset reset.` };
 }
@@ -4987,38 +5685,17 @@ function toolListBranches() {
 
 // --- Tier 1: Briefing, File Locking, Decisions, Recovery ---
 
-// Helpers for new data files
-function readJsonFile(file) { if (!fs.existsSync(file)) return null; try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; } }
-// File-to-cache-key map: writeJsonFile auto-invalidates the right cache entry
-const _fileCacheKeys = {};
-_fileCacheKeys[DECISIONS_FILE] = 'decisions';
-_fileCacheKeys[KB_FILE] = 'kb';
-_fileCacheKeys[LOCKS_FILE] = 'locks';
-_fileCacheKeys[PROGRESS_FILE] = 'progress';
-_fileCacheKeys[VOTES_FILE] = 'votes';
-_fileCacheKeys[REVIEWS_FILE] = 'reviews';
-_fileCacheKeys[DEPS_FILE] = 'deps';
-_fileCacheKeys[REPUTATION_FILE] = 'reputation';
-_fileCacheKeys[RULES_FILE] = 'rules';
-
-function writeJsonFile(file, data) {
-  ensureDataDir();
-  const str = JSON.stringify(data);
-  if (str && str.length > 0) {
-    // Use file lock to prevent concurrent write corruption
-    const lockPath = file + '.lock';
-    let locked = false;
-    try { fs.writeFileSync(lockPath, String(process.pid), { flag: 'wx' }); locked = true; } catch {}
-    try {
-      fs.writeFileSync(file, str);
-    } finally {
-      if (locked) try { fs.unlinkSync(lockPath); } catch {}
-    }
-    // Auto-invalidate cache for this file
-    const cacheKey = _fileCacheKeys[file];
-    if (cacheKey) invalidateCache(cacheKey);
-  }
-}
+// readJsonFile, writeJsonFile, registerFileCacheKey imported from lib/file-io.js
+// Register file-to-cache-key mappings so writeJsonFile auto-invalidates
+registerFileCacheKey(DECISIONS_FILE, 'decisions');
+registerFileCacheKey(KB_FILE, 'kb');
+registerFileCacheKey(LOCKS_FILE, 'locks');
+registerFileCacheKey(PROGRESS_FILE, 'progress');
+registerFileCacheKey(VOTES_FILE, 'votes');
+registerFileCacheKey(REVIEWS_FILE, 'reviews');
+registerFileCacheKey(DEPS_FILE, 'deps');
+registerFileCacheKey(REPUTATION_FILE, 'reputation');
+registerFileCacheKey(RULES_FILE, 'rules');
 
 function getDecisions() { return cachedRead('decisions', () => readJsonFile(DECISIONS_FILE) || [], 2000); }
 function getKB() { return cachedRead('kb', () => readJsonFile(KB_FILE) || {}, 2000); }
@@ -5029,6 +5706,71 @@ function getReviews() { return cachedRead('reviews', () => readJsonFile(REVIEWS_
 function getDeps() { return cachedRead('deps', () => readJsonFile(DEPS_FILE) || [], 2000); }
 function getRules() { return cachedRead('rules', () => readJsonFile(RULES_FILE) || [], 2000); }
 
+// --- Notification system ---
+const MAX_NOTIFICATIONS = 500;
+
+function getNotifications() {
+  return readJsonFile(NOTIFICATIONS_FILE) || [];
+}
+
+function saveNotifications(notifs) {
+  // Prune to max cap
+  if (notifs.length > MAX_NOTIFICATIONS) {
+    notifs = notifs.slice(notifs.length - MAX_NOTIFICATIONS);
+  }
+  writeJsonFile(NOTIFICATIONS_FILE, notifs);
+}
+
+function appendNotification(type, sourceAgent, summary, relatedId) {
+  const notifs = getNotifications();
+  notifs.push({
+    id: 'notif_' + Date.now().toString(36) + Math.random().toString(36).slice(2, 6),
+    type: type,
+    source_agent: sourceAgent || registeredName || '__system__',
+    related_id: relatedId || null,
+    summary: summary,
+    timestamp: new Date().toISOString(),
+    read_by: [],
+  });
+  saveNotifications(notifs);
+}
+
+function toolGetNotifications(since, type) {
+  if (!registeredName) return { error: 'You must call register() first' };
+  let notifs = getNotifications();
+  // Filter unread for this agent
+  notifs = notifs.filter(n => !n.read_by.includes(registeredName));
+  if (since) {
+    const sinceTs = new Date(since).getTime();
+    notifs = notifs.filter(n => new Date(n.timestamp).getTime() > sinceTs);
+  }
+  if (type) {
+    notifs = notifs.filter(n => n.type === type);
+  }
+  // Mark as read
+  if (notifs.length > 0) {
+    const allNotifs = getNotifications();
+    const readIds = new Set(notifs.map(n => n.id));
+    for (const n of allNotifs) {
+      if (readIds.has(n.id) && !n.read_by.includes(registeredName)) {
+        n.read_by.push(registeredName);
+      }
+    }
+    saveNotifications(allNotifs);
+  }
+  return {
+    count: notifs.length,
+    notifications: notifs.map(n => ({
+      id: n.id,
+      type: n.type,
+      source_agent: n.source_agent,
+      related_id: n.related_id,
+      summary: n.summary,
+      timestamp: n.timestamp,
+    })),
+  };
+}
+
 // --- Channel helpers ---
 const CHANNELS_FILE_PATH = path.join(DATA_DIR, 'channels.json');
 
@@ -5166,7 +5908,7 @@ function escalateBlockedTasks() {
       }
     }
     if (changed) saveTasks(tasks);
-  } catch {}
+  } catch (e) { log.warn("watchdog check failed:", e.message); }
 }
 
 // Stand-up meetings: periodic team check-ins triggered by heartbeat
@@ -5183,7 +5925,7 @@ function triggerStandupIfDue() {
     const standupFile = path.join(DATA_DIR, '.last-standup');
     let lastStandup = 0;
     if (fs.existsSync(standupFile)) {
-      try { lastStandup = parseInt(fs.readFileSync(standupFile, 'utf8').trim()) || 0; } catch {}
+      try { lastStandup = parseInt(fs.readFileSync(standupFile, 'utf8').trim()) || 0; } catch (e) { log.debug('standup file read failed:', e.message); }
     }
     if (now - lastStandup < intervalMs) return;
 
@@ -5207,7 +5949,116 @@ function triggerStandupIfDue() {
     summary += ' Each agent: report what you did, what\'s blocked, what\'s next. Then call listen_group().';
 
     broadcastSystemMessage(summary, registeredName);
-  } catch {}
+  } catch (e) { log.warn("standup trigger failed:", e.message); }
+}
+
+// --- Agent status change detection (heartbeat-driven) ---
+const _prevAgentAlive = {};
+function detectAgentStatusChanges(agents) {
+  for (const [name, info] of Object.entries(agents)) {
+    if (name === registeredName) continue;
+    const alive = isPidAlive(info.pid, info.last_activity);
+    const wasAlive = _prevAgentAlive[name];
+    if (wasAlive !== undefined && wasAlive !== alive) {
+      if (!alive) {
+        broadcastSystemMessage(`[STATUS] ${name} is unreachable`, name);
+        appendNotification('agent_offline', name, `${name} went offline`, null);
+      } else {
+        broadcastSystemMessage(`[STATUS] ${name} is back online`, null);
+        appendNotification('agent_online', name, `${name} came back online`, null);
+      }
+    }
+    _prevAgentAlive[name] = alive;
+  }
+}
+
+// --- Auto-nudge system: detect agents that haven't called listen() recently ---
+const AUTO_NUDGE_THRESHOLD_MS = 30000; // 30 seconds
+const _lastNudgeSent = {}; // Track when we last nudged each agent
+
+function checkListenCompliance(agents) {
+  const now = Date.now();
+  
+  for (const [name, info] of Object.entries(agents)) {
+    if (name === registeredName) continue; // Skip self
+    if (!isPidAlive(info.pid, info.last_activity)) continue; // Skip dead agents
+
+    // Skip agents currently in a listen() call — they're compliant
+    if (info.is_listening) continue;
+
+    // Skip Coordinator (lead role) in responsive mode — they use check_messages, not listen()
+    try {
+      const profiles = getProfiles();
+      if (profiles[name] && profiles[name].role === 'lead') {
+        const coordMode = (getConfig().coordinator_mode || 'responsive');
+        if (coordMode === 'responsive') continue;
+      }
+    } catch (_) { /* fall through */ }
+
+    // Skip agents that registered recently (within 60s) — give them time to call listen()
+    const registeredAt = info.registered_at ? new Date(info.registered_at).getTime() : 0;
+    if (registeredAt && (now - registeredAt) < 60000) continue;
+
+    // Check if agent has recent activity but no recent listen call
+    const lastActivity = info.last_activity ? new Date(info.last_activity).getTime() : 0;
+    const timeSinceActivity = now - lastActivity;
+
+    // Only check agents that have been active recently (within 5 minutes)
+    if (timeSinceActivity > 300000) continue; // Skip inactive agents
+
+    // Determine agent's start time and role for filtering
+    const startedAt = info.started_at ? new Date(info.started_at).getTime() : lastActivity || now;
+    const profiles = getProfiles();
+    const role = (profiles[name] || {}).role;
+
+    // GUARD: Skip Coordinator role (they orchestrate, let them skip listen cycles)
+    if (role === 'Coordinator') continue;
+
+    // GUARD: Skip agents registered within the last 60 seconds (grace period)
+    if (now - startedAt < 60000) continue;
+
+    // GUARD: Skip agents currently in a listen loop
+    if (info.listening_since) continue;
+    
+    // Check for recent listen call in heartbeat file
+    // Fallback to registry last_listened_at before defaulting to startedAt
+    let lastListenCall = info.last_listened_at ? new Date(info.last_listened_at).getTime() : startedAt;
+    
+    try {
+      const heartbeatPath = heartbeatFile(name);
+      if (fs.existsSync(heartbeatPath)) {
+        const heartbeat = JSON.parse(fs.readFileSync(heartbeatPath, 'utf8'));
+        if (heartbeat.last_listen_call) {
+          lastListenCall = new Date(heartbeat.last_listen_call).getTime();
+        } else if (heartbeat.listen_history && heartbeat.listen_history.length > 0) {
+          // Fallback to latest history entry
+          lastListenCall = heartbeat.listen_history[0];
+        }
+      }
+    } catch (e) {
+      // Ignore heartbeat read errors
+      continue;
+    }
+    
+    // Calculate time since last listen call
+    const timeSinceListenCall = now - lastListenCall;
+    
+    // If agent has been active but hasn't called listen() in 30+ seconds, nudge them
+    if (timeSinceListenCall > AUTO_NUDGE_THRESHOLD_MS) {
+      // Avoid spamming - only nudge once every 2 minutes per agent
+      const lastNudge = _lastNudgeSent[name] || 0;
+      if (now - lastNudge > 120000) { // 2 minutes
+        _lastNudgeSent[name] = now;
+        
+        // Log only — don't inject messages. Agents that lost listen() can't
+        // receive messages anyway; the in-server tool response warnings and
+        // 5-call blocking handle active agents. Injecting CRITICAL messages
+        // just spams the dashboard with no effect.
+        const minutesSinceListenCall = Math.round(timeSinceListenCall / 60000);
+        log.info(`[auto-nudge] ${name} hasn't called listen() in ${minutesSinceListenCall}m`);
+      }
+    }
+  }
 }
 
 // Auto-recovery: snapshot dead agent state before cleanup
@@ -5249,7 +6100,7 @@ function snapshotDeadAgents(agents) {
           kb_entries_written: kbKeysWritten,
         });
       }
-    } catch {}
+    } catch (e) { log.warn("dead agent snapshot failed:", e.message); }
 
     // Quality Lead instant failover: if dead agent was Quality Lead, promote replacement immediately
     try {
@@ -5301,7 +6152,7 @@ function snapshotDeadAgents(agents) {
           broadcastSystemMessage(`[MONITOR FAILOVER] ${name} (Monitor) went offline. ${newMonitor} has been auto-promoted.`, newMonitor);
         }
       }
-    } catch {}
+    } catch (e) { log.warn("monitor failover failed:", e.message); }
   }
 }
 
@@ -5352,9 +6203,37 @@ function fireEvent(eventName, data) {
       }
       break;
     }
+    case 'review_approved': {
+      if (data.author && agents[data.author] && isPidAlive(agents[data.author].pid, agents[data.author].last_activity)) {
+        sendSystemMessage(data.author, `[EVENT] "${data.file}" approved by ${data.reviewer}. You should commit your changes now.`);
+      }
+      break;
+    }
   }
+
+  // Hook system: emit to all subscribers of mapped events
+  try {
+    const hooksLib = require('./lib/hooks');
+    const hookEvent = EVENT_TO_HOOK[eventName];
+    if (hookEvent) {
+      const hookData = { ...data, _source_agent: registeredName };
+      const notifications = hooksLib.emit(hookEvent, hookData);
+      for (const n of notifications) {
+        if (agents[n.agent] && isPidAlive(agents[n.agent].pid, agents[n.agent].last_activity)) {
+          sendSystemMessage(n.agent, n.message);
+        }
+      }
+    }
+  } catch (e) { log.debug('hook emit failed:', e.message); }
 }
 
+// Map internal event names to hook event names
+const EVENT_TO_HOOK = {
+  task_complete: 'task.status_changed',
+  review_approved: 'review.submitted',
+  rule_changed: 'rule.changed',
+};
+
 function toolGetGuide(level = 'standard') {
   if (!registeredName) return { error: 'You must call register() first' };
   if (!['minimal', 'standard', 'full'].includes(level)) return { error: 'Level must be "minimal", "standard", or "full"' };
@@ -5723,11 +6602,12 @@ function toolSubmitReview(reviewId, status, feedback) {
       rep[review.requested_by].demoted = false;
       writeJsonFile(REPUTATION_FILE, rep);
     }
-    // Notify requester
+    // Notify requester and fire review_approved event
     const agents = getAgents();
     if (agents[review.requested_by]) {
       sendSystemMessage(review.requested_by, `[REVIEW] ${registeredName} approved "${review.file}": ${review.feedback || 'Looks good!'}`);
     }
+    fireEvent('review_approved', { file: review.file, reviewer: registeredName, author: review.requested_by });
   }
 
   // Auto-approve check: if this is a re-submission and auto_approve_next is set
@@ -6040,11 +6920,12 @@ function toolSuggestTask() {
 
 // --- Rules system: project-level rules visible in dashboard and injected into agent guides ---
 
-function toolAddRule(text, category = 'custom') {
+function toolAddRule(text, category = 'custom', scope = null) {
   if (!registeredName) return { error: 'You must call register() first' };
   if (!text || !text.trim()) return { error: 'Rule text cannot be empty' };
   const validCategories = ['safety', 'workflow', 'code-style', 'communication', 'custom'];
   if (!validCategories.includes(category)) return { error: `Category must be one of: ${validCategories.join(', ')}` };
+  if (scope && typeof scope !== 'object') return { error: 'scope must be an object with optional fields: role, provider, agent' };
 
   const rules = getRules();
   const rule = {
@@ -6055,9 +6936,25 @@ function toolAddRule(text, category = 'custom') {
     created_at: new Date().toISOString(),
     active: true,
   };
+  if (scope) {
+    if (scope.role) rule.scope_role = String(scope.role).toLowerCase();
+    if (scope.provider) rule.scope_provider = String(scope.provider).toLowerCase();
+    if (scope.agent) rule.scope_agent = String(scope.agent);
+  }
   rules.push(rule);
   writeJsonFile(RULES_FILE, rules);
-  return { success: true, rule_id: rule.id, message: `Rule added: "${text.substring(0, 80)}". All agents will see this in their guide.` };
+  const scopeMsg = scope ? ` (scoped to ${JSON.stringify(scope)})` : '';
+  fireEvent('rule_changed', {
+    action: 'added',
+    rule_id: rule.id,
+    text: rule.text,
+    category: rule.category,
+    scope_role: rule.scope_role || null,
+    scope_provider: rule.scope_provider || null,
+    scope_agent: rule.scope_agent || null,
+    changed_by: registeredName,
+  });
+  return { success: true, rule_id: rule.id, message: `Rule added: "${text.substring(0, 80)}"${scopeMsg}. Matching agents will see this in their guide.` };
 }
 
 function toolListRules() {
@@ -6080,6 +6977,16 @@ function toolRemoveRule(ruleId) {
   if (idx === -1) return { error: `Rule not found: ${ruleId}` };
   const removed = rules.splice(idx, 1)[0];
   writeJsonFile(RULES_FILE, rules);
+  fireEvent('rule_changed', {
+    action: 'removed',
+    rule_id: removed.id,
+    text: removed.text,
+    category: removed.category,
+    scope_role: removed.scope_role || null,
+    scope_provider: removed.scope_provider || null,
+    scope_agent: removed.scope_agent || null,
+    changed_by: registeredName,
+  });
   return { success: true, removed: removed.text.substring(0, 80), message: 'Rule removed.' };
 }
 
@@ -6091,14 +6998,252 @@ function toolToggleRule(ruleId) {
   if (!rule) return { error: `Rule not found: ${ruleId}` };
   rule.active = !rule.active;
   writeJsonFile(RULES_FILE, rules);
+  fireEvent('rule_changed', {
+    action: rule.active ? 'activated' : 'deactivated',
+    rule_id: rule.id,
+    text: rule.text,
+    category: rule.category,
+    scope_role: rule.scope_role || null,
+    scope_provider: rule.scope_provider || null,
+    scope_agent: rule.scope_agent || null,
+    changed_by: registeredName,
+  });
   return { success: true, rule_id: ruleId, active: rule.active, message: `Rule ${rule.active ? 'activated' : 'deactivated'}.` };
 }
 
+// --- Audit log ---
+
+function logViolation(type, agent, details) {
+  const entry = {
+    timestamp: new Date().toISOString(),
+    type,
+    agent,
+    details: (details || '').substring(0, 1000),
+  };
+  try {
+    fs.appendFileSync(AUDIT_LOG_FILE, JSON.stringify(entry) + '\n');
+  } catch (e) { log.debug('audit log write failed:', e.message); }
+  return entry;
+}
+
+function toolLogViolation(type, details) {
+  if (!registeredName) return { error: 'You must call register() first' };
+  if (!type) return { error: 'type is required (e.g., "review_skipped", "push_without_approval", "rule_violated")' };
+  const entry = logViolation(type, registeredName, details);
+  return { success: true, logged: entry, message: `Violation logged: ${type}` };
+}
+
+// --- Push approval system ---
+
+const PUSH_AUTO_APPROVE_MS = 120000; // 2 minutes
+
+function getPushRequests() { return cachedRead('push_requests', () => readJsonFile(PUSH_REQUESTS_FILE) || [], 2000); }
+
+function toolRequestPushApproval(branch, description) {
+  if (!registeredName) return { error: 'You must call register() first' };
+  if (!branch) return { error: 'branch is required' };
+
+  const agents = getAgents();
+  const aliveOthers = Object.keys(agents).filter(n => n !== registeredName && isPidAlive(agents[n].pid, agents[n].last_activity));
+
+  // Auto-approve if no other agents online
+  if (aliveOthers.length === 0) {
+    return { approved: true, auto: true, message: 'No other agents online — auto-approved. You may push.' };
+  }
+
+  const requests = getPushRequests();
+  const id = 'push_' + generateId();
+  const request = {
+    id,
+    branch: branch.substring(0, 100),
+    description: (description || '').substring(0, 500),
+    requested_by: registeredName,
+    requested_at: new Date().toISOString(),
+    status: 'pending',
+    acked_by: null,
+  };
+  requests.push(request);
+  writeJsonFile(PUSH_REQUESTS_FILE, requests);
+
+  broadcastSystemMessage(`[PUSH REQUEST] ${registeredName} wants to push branch "${branch}". ${description || ''}. Call ack_push("${id}") to approve.`, registeredName);
+
+  return {
+    request_id: id,
+    status: 'pending',
+    waiting_on: aliveOthers,
+    auto_approve_after: '2 minutes',
+    message: `Push request created. Waiting for approval from ${aliveOthers.join(', ')}. Auto-approves in 2 minutes if no response.`,
+  };
+}
+
+function toolAckPush(requestId) {
+  if (!registeredName) return { error: 'You must call register() first' };
+  if (!requestId) return { error: 'request_id is required' };
+
+  const requests = getPushRequests();
+  const req = requests.find(r => r.id === requestId);
+  if (!req) return { error: `Push request not found: ${requestId}` };
+  if (req.requested_by === registeredName) return { error: 'Cannot approve your own push request.' };
+  if (req.status !== 'pending') return { error: `Push request already ${req.status}.` };
+
+  req.status = 'approved';
+  req.acked_by = registeredName;
+  req.acked_at = new Date().toISOString();
+  writeJsonFile(PUSH_REQUESTS_FILE, requests);
+
+  sendSystemMessage(req.requested_by, `[PUSH APPROVED] ${registeredName} approved your push of "${req.branch}". You may push now.`);
+
+  return { success: true, request_id: requestId, message: `Push approved for ${req.requested_by} on branch "${req.branch}".` };
+}
+
+function checkPushAutoApprove(requestId) {
+  const requests = getPushRequests();
+  const req = requests.find(r => r.id === requestId);
+  if (!req || req.status !== 'pending') return;
+
+  const elapsed = Date.now() - new Date(req.requested_at).getTime();
+  if (elapsed >= PUSH_AUTO_APPROVE_MS) {
+    req.status = 'auto_approved';
+    req.acked_by = '__system__';
+    req.acked_at = new Date().toISOString();
+    writeJsonFile(PUSH_REQUESTS_FILE, requests);
+    sendSystemMessage(req.requested_by, `[PUSH AUTO-APPROVED] No response after 2 minutes. Push of "${req.branch}" auto-approved. You may push now.`);
+  }
+}
+
+// --- Modular tools (tools/) ---
+// Each module exports { definitions, handlers } via a context-injection pattern.
+// Context provides shared state, helper functions, and file paths.
+
+const _governanceCtx = {
+  state: { get registeredName() { return registeredName; } },
+  helpers: {
+    getVotes, getReviews, getRules, getPushRequests,
+    getAgents, isPidAlive, getReputation, getTasks, saveTasks,
+    generateId, readJsonFile, writeJsonFile, cachedRead, invalidateCache,
+    broadcastSystemMessage, sendSystemMessage, touchActivity, fireEvent,
+  },
+  files: {
+    VOTES_FILE, REVIEWS_FILE, RULES_FILE,
+    PUSH_REQUESTS_FILE, AUDIT_LOG_FILE, REPUTATION_FILE,
+  },
+};
+const governance = require('./tools/governance')(_governanceCtx);
+
+const _tasksCtx = {
+  state: {
+    get registeredName() { return registeredName; },
+    get messageSeq() { return messageSeq; },
+    set messageSeq(v) { messageSeq = v; },
+    get currentBranch() { return currentBranch; },
+  },
+  helpers: {
+    getTasks, saveTasks, getAgents, isPidAlive, generateId, writeJsonFile,
+    broadcastSystemMessage, sendSystemMessage, touchActivity, fireEvent,
+    ensureDataDir, getProfiles, getReviews, getReputation, getDeps,
+    getChannelsData, saveChannelsData, isGroupMode,
+    getWorkspace, saveWorkspace, appendNotification,
+    getWorkflows, saveWorkflows, saveWorkflowCheckpoint, findReadySteps,
+    getMessagesFile, getHistoryFile, logViolation, cachedRead,
+  },
+  files: { TASKS_FILE, REVIEWS_FILE, DEPS_FILE },
+};
+const tasks = require('./tools/tasks')(_tasksCtx);
+
+const _workflowsCtx = {
+  state: {
+    get registeredName() { return registeredName; },
+    get messageSeq() { return messageSeq; },
+    set messageSeq(v) { messageSeq = v; },
+    get currentBranch() { return currentBranch; },
+  },
+  helpers: {
+    getWorkflows, saveWorkflows, saveWorkflowCheckpoint, findReadySteps,
+    getAgents, isPidAlive, getTasks, saveTasks, generateId, ensureDataDir,
+    broadcastSystemMessage, sendSystemMessage, touchActivity, appendNotification,
+    getMessagesFile, getHistoryFile, canSendTo, generateCompletionReport,
+  },
+  files: {},
+};
+const workflows = require('./tools/workflows')(_workflowsCtx);
+
+const _knowledgeCtx = {
+  state: {
+    get registeredName() { return registeredName; },
+    get currentBranch() { return currentBranch; },
+  },
+  helpers: {
+    getDecisions, getKB, getProgressData, getCompressed, getLocks, getConfig,
+    generateId, writeJsonFile, readJsonFile, touchActivity, tailReadJsonl,
+    getHistoryFile, getAgents, isPidAlive, getProfiles, getTasks, cachedRead,
+  },
+  files: { DECISIONS_FILE, KB_FILE, PROGRESS_FILE, COMPRESSED_FILE },
+};
+const knowledge = require('./tools/knowledge')(_knowledgeCtx);
+
+const _channelsCtx = {
+  state: { get registeredName() { return registeredName; } },
+  helpers: {
+    getChannelsData, saveChannelsData, sanitizeName,
+    isChannelMember, getAgentChannels, getChannelMessagesFile,
+    touchActivity,
+  },
+  files: {},
+};
+const channels = require('./tools/channels')(_channelsCtx);
+
+const _safetyCtx = {
+  state: { get registeredName() { return registeredName; } },
+  helpers: {
+    getLocks, getAgents, isPidAlive, getTasks, getDeps,
+    generateId, writeJsonFile, touchActivity,
+  },
+  files: { LOCKS_FILE, DEPS_FILE },
+};
+const safety = require('./tools/safety')(_safetyCtx);
+
+const _systemCtx = {
+  state: {
+    get registeredName() { return registeredName; },
+    get currentBranch() { return currentBranch; },
+  },
+  helpers: {
+    getProfiles, saveProfiles, getWorkspace, saveWorkspace, ensureDataDir,
+    getAgents, getBranches, getHistoryFile, getReputation, touchActivity,
+  },
+  files: {},
+};
+const system = require('./tools/system')(_systemCtx);
+
+const _hooksCtx = {
+  state: { get registeredName() { return registeredName; } },
+};
+const hooks = require('./tools/hooks')(_hooksCtx);
+
+const _messagingCtx = {
+  state: {
+    get registeredName() { return registeredName; },
+    get currentBranch() { return currentBranch; },
+    get lastReadOffset() { return lastReadOffset; },
+    set lastReadOffset(v) { lastReadOffset = v; },
+  },
+  helpers: {
+    getUnconsumedMessages, getConsumedIds, saveConsumedIds, markAsRead,
+    getNotifications, saveNotifications, getAcks, getPermissions,
+    getAgents, isPidAlive, getConfig, touchActivity,
+    tailReadJsonl, readJsonl, getMessagesFile, getHistoryFile,
+    getAgentChannels, getChannelHistoryFile,
+    withFileLock,
+  },
+  files: { ACKS_FILE },
+};
+const messaging = require('./tools/messaging')(_messagingCtx);
+
 // --- MCP Server setup ---
 
 const server = new Server(
-  { name: 'neohive', version: '6.0.0' },
-  { capabilities: { tools: {} } }
+  { name: 'neohive', version: '6.1.0' },
+  { capabilities: { tools: { listChanged: true } } }
 );
 
 server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -6118,8 +7263,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
               type: 'string',
               description: 'AI provider/CLI name (e.g. "Claude", "OpenAI", "Gemini"). Shown in dashboard.',
             },
+            skills: {
+              type: 'array',
+              items: { type: 'string' },
+              description: 'Skills like "python", "testing", "frontend", "design". Used for smart task routing.',
+            },
           },
           required: ['name'],
+          additionalProperties: false,
         },
       },
       {
@@ -6128,6 +7279,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         inputSchema: {
           type: 'object',
           properties: {},
+          additionalProperties: false,
         },
       },
       {
@@ -6152,8 +7304,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
               type: 'string',
               description: 'Channel to send to (optional — omit for #general). Use join_channel() first to create channels.',
             },
+            priority: {
+              type: 'string',
+              enum: ['critical', 'normal', 'low'],
+              description: 'Message priority (optional — auto-classified if omitted). Critical messages are delivered first and retained longer.',
+            },
           },
           required: ['content'],
+          additionalProperties: false,
         },
       },
       {
@@ -6171,6 +7329,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
               description: 'Only return messages from this specific agent (optional)',
             },
           },
+          additionalProperties: false,
         },
       },
       {
@@ -6185,76 +7344,63 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
           },
           required: ['content'],
+          additionalProperties: false,
         },
       },
       {
         name: 'listen',
-        description: 'Listen for messages indefinitely. Auto-detects conversation mode: in group/managed mode, behaves like listen_group() (returns batched messages with agent statuses). In direct mode, returns one message at a time. Either listen() or listen_group() works in any mode — they auto-delegate to the correct behavior.',
+        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).',
         inputSchema: {
           type: 'object',
           properties: {
-            from: {
+            mode: {
               type: 'string',
-              description: 'Only listen for messages from this specific agent (optional)',
+              enum: ['standard', 'group', 'codex'],
+              description: 'Listen mode: "standard" (default, direct), "group" (group/managed batched), "codex" (Codex CLI 90s cap). Auto-detected when omitted.',
             },
-          },
-        },
-      },
-      {
-        name: 'listen_codex',
-        description: 'ONLY for Codex CLI agents — do NOT use if you are Claude Code or Gemini CLI. Same as listen() but returns after 90 seconds due to Codex tool timeout limits. Claude and Gemini agents must use listen() instead.',
-        inputSchema: {
-          type: 'object',
-          properties: {
             from: {
               type: 'string',
               description: 'Only listen for messages from this specific agent (optional)',
             },
-          },
-        },
-      },
-      {
-        name: 'check_messages',
-        description: 'Non-blocking PEEK at your inbox — shows message previews but does NOT consume them. Use listen() to actually receive and process messages. Do NOT call this in a loop — it wastes tokens returning the same messages repeatedly. Use listen() instead which blocks efficiently and consumes messages.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            from: {
+            outcome: {
               type: 'string',
-              description: 'Only show messages from this specific agent (optional)',
+              enum: ['completed', 'blocked', 'failed', 'in_progress'],
+              description: 'Optional: report the outcome of your last task before listening. "completed" marks task done, "blocked" marks it blocked, "failed" marks it permanently blocked.',
             },
-          },
-        },
-      },
-      {
-        name: 'ack_message',
-        description: 'Acknowledge that you have processed a message. Lets the sender verify delivery via get_history.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            message_id: {
+            task_id: {
+              type: 'string',
+              description: 'Task ID to update with the outcome (required when outcome is set and outcome is not "in_progress")',
+            },
+            summary: {
               type: 'string',
-              description: 'ID of the message to acknowledge',
+              description: 'Optional: brief summary of what was done or why it was blocked (used as task notes)',
             },
           },
-          required: ['message_id'],
+          additionalProperties: false,
         },
       },
+      // --- Unified messages tool (consolidates check/consume/history/search/ack) ---
       {
-        name: 'get_history',
-        description: 'Get conversation history. Optionally filter by thread.',
+        name: 'messages',
+        description: 'Unified message management. action="check" peeks at unconsumed messages, "consume" marks them read, "history" returns conversation history, "search" searches by keyword, "ack" acknowledges a message, "notifications" returns task/workflow/agent notifications.',
         inputSchema: {
           type: 'object',
           properties: {
-            limit: {
-              type: 'number',
-              description: 'Number of recent messages to return (default: 50)',
-            },
-            thread_id: {
+            action: {
               type: 'string',
-              description: 'Filter to only messages in this thread (optional)',
+              enum: ['check', 'consume', 'history', 'search', 'ack', 'notifications'],
+              description: 'Message action: check (peek), consume (mark read), history, search, ack, notifications',
             },
+            from: { type: 'string', description: 'Filter by sender agent name (optional)' },
+            limit: { type: 'number', description: 'Max results (default varies by action)' },
+            query: { type: 'string', description: 'Search term — required for action="search"' },
+            message_id: { type: 'string', description: 'Message ID — required for action="ack"' },
+            thread_id: { type: 'string', description: 'Filter by thread ID (optional, action="history")' },
+            since: { type: 'string', description: 'ISO timestamp filter (optional)' },
+            type: { type: 'string', description: 'Notification type filter (optional, action="notifications")' },
           },
+          required: ['action'],
+          additionalProperties: false,
         },
       },
       {
@@ -6273,6 +7419,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
           },
           required: ['to', 'context'],
+          additionalProperties: false,
         },
       },
       {
@@ -6295,173 +7442,26 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
           },
           required: ['file_path'],
+          additionalProperties: false,
         },
       },
+      // --- Task tools (from tools/tasks.js) ---
+      ...tasks.definitions,
+      // --- Knowledge tools (from tools/knowledge.js) ---
+      ...knowledge.definitions,
       {
-        name: 'create_task',
-        description: 'Create a task and optionally assign it to another agent. Use for structured work delegation in multi-agent teams.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            title: { type: 'string', description: 'Short task title' },
-            description: { type: 'string', description: 'Detailed task description' },
-            assignee: { type: 'string', description: 'Agent to assign to (optional, auto-assigns with 2 agents)' },
-          },
-          required: ['title'],
-        },
-      },
-      {
-        name: 'update_task',
-        description: 'Update a task status. Statuses: pending, in_progress, in_review, done, blocked.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            task_id: { type: 'string', description: 'Task ID to update' },
-            status: { type: 'string', enum: ['pending', 'in_progress', 'done', 'blocked'], description: 'New status' },
-            notes: { type: 'string', description: 'Optional progress note' },
-          },
-          required: ['task_id', 'status'],
-        },
-      },
-      {
-        name: 'list_tasks',
-        description: 'List all tasks, optionally filtered by status or assignee.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            status: { type: 'string', enum: ['pending', 'in_progress', 'done', 'blocked'], description: 'Filter by status' },
-            assignee: { type: 'string', description: 'Filter by assignee agent name' },
-          },
-        },
-      },
-      {
-        name: 'get_summary',
-        description: 'Get a condensed summary of the conversation so far. Useful when context is getting long and you need a quick recap of what was discussed.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            last_n: {
-              type: 'number',
-              description: 'Number of recent messages to summarize (default: 20)',
-            },
-          },
-        },
-      },
-      {
-        name: 'search_messages',
-        description: 'Search conversation history by keyword. Returns matching messages with previews. Useful for finding past discussions, decisions, or code references.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            query: { type: 'string', description: 'Search term (min 2 chars)' },
-            from: { type: 'string', description: 'Filter by sender agent name (optional)' },
-            limit: { type: 'number', description: 'Max results (default: 20, max: 50)' },
-          },
-          required: ['query'],
-        },
-      },
-      {
-        name: 'reset',
-        description: 'Clear all data files and start fresh. Automatically archives the conversation before clearing.',
+        name: 'reset',
+        description: 'Clear all data files and start fresh. Automatically archives the conversation before clearing.',
         inputSchema: {
           type: 'object',
           properties: {},
+          additionalProperties: false,
         },
       },
-      // --- Phase 1: Profiles ---
-      {
-        name: 'update_profile',
-        description: 'Update your agent profile (display name, avatar, bio, role). Profile data is shown in the dashboard.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            display_name: { type: 'string', description: 'Display name (max 30 chars)' },
-            avatar: { type: 'string', description: 'Avatar URL or data URI (max 64KB)' },
-            bio: { type: 'string', description: 'Short bio (max 200 chars)' },
-            role: { type: 'string', description: 'Role/title (max 30 chars, e.g. "Architect", "Reviewer")' },
-          },
-        },
-      },
-      // --- Phase 2: Workspaces ---
-      {
-        name: 'workspace_write',
-        description: 'Write a key-value entry to your workspace. Other agents can read your workspace but only you can write to it. Max 50 keys, 100KB per value.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            key: { type: 'string', description: 'Key name (1-50 alphanumeric/underscore/hyphen/dot chars)' },
-            content: { type: 'string', description: 'Content to store (max 100KB)' },
-          },
-          required: ['key', 'content'],
-        },
-      },
-      {
-        name: 'workspace_read',
-        description: 'Read workspace entries. Read your own or another agent\'s workspace. Omit key to read all entries.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            key: { type: 'string', description: 'Specific key to read (optional — omit for all keys)' },
-            agent: { type: 'string', description: 'Agent whose workspace to read (optional — defaults to yourself)' },
-          },
-        },
-      },
-      {
-        name: 'workspace_list',
-        description: 'List workspace keys. Specify agent for one workspace, or omit for all agents\' workspace summaries.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            agent: { type: 'string', description: 'Agent name (optional — omit for all)' },
-          },
-        },
-      },
-      // --- Phase 3: Workflows ---
-      {
-        name: 'create_workflow',
-        description: 'Create a multi-step workflow pipeline. Each step can have a description, assignee, and depends_on (step IDs). Set autonomous=true for proactive work loop (agents auto-advance, no human gates). Set parallel=true to run independent steps simultaneously.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            name: { type: 'string', description: 'Workflow name (max 50 chars)' },
-            steps: {
-              type: 'array',
-              description: 'Array of steps. Each step is a string (description) or {description, assignee, depends_on: [stepIds]}.',
-              items: {
-                oneOf: [
-                  { type: 'string' },
-                  { type: 'object', properties: { description: { type: 'string' }, assignee: { type: 'string' }, depends_on: { type: 'array', items: { type: 'number' }, description: 'Step IDs this step depends on (must complete first)' } }, required: ['description'] },
-                ],
-              },
-            },
-            autonomous: { type: 'boolean', default: false, description: 'If true, agents auto-advance through steps without waiting for approval. Enables proactive work loop, relaxed send limits, fast cooldowns, and 30s listen cap.' },
-            parallel: { type: 'boolean', default: false, description: 'If true, steps with met dependencies run in parallel (multiple agents work simultaneously)' },
-          },
-          required: ['name', 'steps'],
-        },
-      },
-      {
-        name: 'advance_workflow',
-        description: 'Mark the current step as done and start the next step. Auto-sends a handoff message to the next assignee.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            workflow_id: { type: 'string', description: 'Workflow ID' },
-            notes: { type: 'string', description: 'Optional completion notes (max 500 chars)' },
-          },
-          required: ['workflow_id'],
-        },
-      },
-      {
-        name: 'workflow_status',
-        description: 'Get status of a specific workflow or all workflows. Shows step progress and completion percentage.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            workflow_id: { type: 'string', description: 'Workflow ID (optional — omit for all workflows)' },
-          },
-        },
-      },
+      // --- System tools (from tools/system.js): profiles, workspaces, branches, reputation ---
+      ...system.definitions,
+      // --- Workflow tools (from tools/workflows.js) ---
+      ...workflows.definitions,
       // --- Phase 4: Branching ---
       {
         name: 'fork_conversation',
@@ -6473,6 +7473,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             branch_name: { type: 'string', description: 'Name for the new branch (1-20 alphanumeric chars)' },
           },
           required: ['branch_name'],
+          additionalProperties: false,
         },
       },
       {
@@ -6484,16 +7485,10 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             branch_name: { type: 'string', description: 'Branch to switch to' },
           },
           required: ['branch_name'],
+          additionalProperties: false,
         },
       },
-      {
-        name: 'list_branches',
-        description: 'List all conversation branches with message counts and metadata.',
-        inputSchema: {
-          type: 'object',
-          properties: {},
-        },
-      },
+      // list_branches included via ...system.definitions above
       {
         name: 'set_conversation_mode',
         description: 'Switch between "direct" (point-to-point), "group" (free multi-agent chat with auto-broadcast), or "managed" (structured turn-taking with a manager who controls who speaks). Use managed mode for 3+ agent teams to prevent chaos.',
@@ -6503,183 +7498,30 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             mode: { type: 'string', description: '"direct" (default), "group" for free chat, or "managed" for structured turn-taking', enum: ['group', 'direct', 'managed'] },
           },
           required: ['mode'],
+          additionalProperties: false,
         },
       },
-      {
-        name: 'listen_group',
-        description: 'Listen for messages in group or managed conversation mode. Auto-detects mode: in direct mode, behaves like listen(). Returns ALL unconsumed messages as a sorted batch (system > threaded > direct > broadcast), plus batch_summary, agent statuses, and hints. Either listen() or listen_group() works in any mode — they auto-delegate. Call again immediately after responding.',
-        inputSchema: {
-          type: 'object',
-          properties: {},
-        },
-      },
-      // --- Channels ---
-      {
-        name: 'join_channel',
-        description: 'Join or create a channel. Channels let sub-teams communicate without flooding the main conversation. Auto-joined to #general on register. Use channels when team size > 4.',
-        inputSchema: { type: 'object', properties: { name: { type: 'string', description: 'Channel name (1-20 chars, e.g. "backend", "testing")' }, description: { type: 'string', description: 'Channel description (optional, max 200 chars)' }, rate_limit: { type: 'object', description: 'Optional rate limit config: { max_sends_per_minute: 10 }. Any member can update.', properties: { max_sends_per_minute: { type: 'number' } } } }, required: ['name'] },
-      },
-      {
-        name: 'leave_channel',
-        description: 'Leave a channel. You will stop receiving messages from it. Cannot leave #general.',
-        inputSchema: { type: 'object', properties: { name: { type: 'string', description: 'Channel to leave' } }, required: ['name'] },
-      },
-      {
-        name: 'list_channels',
-        description: 'List all channels with members, message counts, and your membership status.',
-        inputSchema: { type: 'object', properties: {} },
-      },
+      // --- Channel tools (from tools/channels.js) ---
+      ...channels.definitions,
       // --- Briefing & Recovery ---
       {
         name: 'get_guide',
         description: 'Get the collaboration guide — all tool categories, critical rules, and workflow patterns. Call this if you are unsure how to use the tools or need a refresher on best practices. Use level="minimal" for a compact refresher (saves context tokens), "full" for complete reference with tool details.',
-        inputSchema: { type: 'object', properties: { level: { type: 'string', enum: ['minimal', 'standard', 'full'], description: 'Guide detail level: "minimal" (~5 rules, saves tokens), "standard" (default, progressive disclosure), "full" (all rules + tool details)' } } },
-      },
-      {
-        name: 'get_briefing',
-        description: 'Get a full project briefing: who is online, active tasks, recent decisions, knowledge base, locked files, progress, and project files. Call this when joining a project or after being away. One call = fully onboarded.',
-        inputSchema: { type: 'object', properties: {} },
-      },
-      // --- File Locking ---
-      {
-        name: 'lock_file',
-        description: 'Lock a file for exclusive editing. Other agents will be warned if they try to edit it. Call unlock_file() when done. Locks auto-release if you disconnect.',
-        inputSchema: { type: 'object', properties: { file_path: { type: 'string', description: 'Relative path to the file to lock' } }, required: ['file_path'] },
-      },
-      {
-        name: 'unlock_file',
-        description: 'Unlock a file you previously locked. Omit file_path to unlock all your files.',
-        inputSchema: { type: 'object', properties: { file_path: { type: 'string', description: 'File to unlock (optional — omit to unlock all)' } } },
-      },
-      // --- Decision Log ---
-      {
-        name: 'log_decision',
-        description: 'Log a team decision so it persists and other agents can reference it. Prevents re-debating the same choices.',
-        inputSchema: { type: 'object', properties: { decision: { type: 'string', description: 'The decision made (max 500 chars)' }, reasoning: { type: 'string', description: 'Why this was decided (optional, max 1000 chars)' }, topic: { type: 'string', description: 'Category like "architecture", "tech-stack", "design" (optional)' } }, required: ['decision'] },
-      },
-      {
-        name: 'get_decisions',
-        description: 'Get all logged decisions, optionally filtered by topic.',
-        inputSchema: { type: 'object', properties: { topic: { type: 'string', description: 'Filter by topic (optional)' } } },
-      },
-      // --- Knowledge Base ---
-      {
-        name: 'kb_write',
-        description: 'Write to the shared team knowledge base. Any agent can read, any agent can write. Use for API specs, conventions, shared data.',
-        inputSchema: { type: 'object', properties: { key: { type: 'string', description: 'Key name (1-50 alphanumeric chars)' }, content: { type: 'string', description: 'Content (max 100KB)' } }, required: ['key', 'content'] },
-      },
-      {
-        name: 'kb_read',
-        description: 'Read from the shared knowledge base. Omit key to read all entries.',
-        inputSchema: { type: 'object', properties: { key: { type: 'string', description: 'Key to read (optional — omit for all)' } } },
-      },
-      {
-        name: 'kb_list',
-        description: 'List all keys in the shared knowledge base with metadata.',
-        inputSchema: { type: 'object', properties: {} },
-      },
-      // --- Progress Tracking ---
-      {
-        name: 'update_progress',
-        description: 'Update feature-level progress. Higher level than tasks — tracks overall feature completion percentage.',
-        inputSchema: { type: 'object', properties: { feature: { type: 'string', description: 'Feature name (max 100 chars)' }, percent: { type: 'number', description: 'Completion percentage 0-100' }, notes: { type: 'string', description: 'Progress notes (optional)' } }, required: ['feature', 'percent'] },
-      },
-      {
-        name: 'get_progress',
-        description: 'Get progress on all features with completion percentages and overall project progress.',
-        inputSchema: { type: 'object', properties: {} },
-      },
-      // --- Voting ---
-      {
-        name: 'call_vote',
-        description: 'Start a vote for the team to decide something. All online agents are notified and can cast their vote.',
-        inputSchema: { type: 'object', properties: { question: { type: 'string', description: 'The question to vote on' }, options: { type: 'array', items: { type: 'string' }, description: 'Array of 2-10 options to choose from' } }, required: ['question', 'options'] },
-      },
-      {
-        name: 'cast_vote',
-        description: 'Cast your vote on an open vote. Vote auto-resolves when all online agents have voted.',
-        inputSchema: { type: 'object', properties: { vote_id: { type: 'string', description: 'Vote ID' }, choice: { type: 'string', description: 'Your choice (must match one of the options)' } }, required: ['vote_id', 'choice'] },
-      },
-      {
-        name: 'vote_status',
-        description: 'Check status of a specific vote or all votes.',
-        inputSchema: { type: 'object', properties: { vote_id: { type: 'string', description: 'Vote ID (optional — omit for all)' } } },
-      },
-      // --- Code Review ---
-      {
-        name: 'request_review',
-        description: 'Request a code review from the team. Creates a review request and notifies all agents.',
-        inputSchema: { type: 'object', properties: { file_path: { type: 'string', description: 'File to review' }, description: { type: 'string', description: 'What to focus on in the review' } }, required: ['file_path'] },
-      },
-      {
-        name: 'submit_review',
-        description: 'Submit a code review — approve or request changes with feedback.',
-        inputSchema: { type: 'object', properties: { review_id: { type: 'string', description: 'Review ID' }, status: { type: 'string', enum: ['approved', 'changes_requested'], description: 'Review result' }, feedback: { type: 'string', description: 'Your review feedback (max 2000 chars)' } }, required: ['review_id', 'status'] },
-      },
-      // --- Dependencies ---
-      {
-        name: 'declare_dependency',
-        description: 'Declare that a task depends on another task. You will be notified when the dependency is complete.',
-        inputSchema: { type: 'object', properties: { task_id: { type: 'string', description: 'Your task that is blocked' }, depends_on: { type: 'string', description: 'Task ID that must complete first' } }, required: ['task_id', 'depends_on'] },
-      },
-      {
-        name: 'check_dependencies',
-        description: 'Check dependency status for a task or all unresolved dependencies.',
-        inputSchema: { type: 'object', properties: { task_id: { type: 'string', description: 'Task ID to check (optional — omit for all unresolved)' } } },
-      },
-      // --- Conversation Compression ---
-      {
-        name: 'get_compressed_history',
-        description: 'Get conversation history with automatic compression. Old messages are summarized into segments, recent messages shown verbatim. Use this when the conversation is long and you need to catch up without overflowing your context.',
-        inputSchema: { type: 'object', properties: {} },
-      },
-      // --- Reputation ---
-      {
-        name: 'get_reputation',
-        description: 'View agent reputation — tasks completed, reviews done, bugs found, strengths. Shows leaderboard when called without agent name.',
-        inputSchema: { type: 'object', properties: { agent: { type: 'string', description: 'Agent name (optional — omit for leaderboard)' } } },
-      },
-      {
-        name: 'suggest_task',
-        description: 'Get a task suggestion based on your strengths, pending tasks, open reviews, and blocked dependencies. Helps you find the most useful thing to do next.',
-        inputSchema: { type: 'object', properties: {} },
-      },
-      // --- Rules tools ---
-      {
-        name: 'add_rule',
-        description: 'Add a project rule that all agents must follow. Rules appear in every agent\'s guide and briefing. Categories: safety, workflow, code-style, communication, custom.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            text: { type: 'string', description: 'The rule text' },
-            category: { type: 'string', description: 'Rule category: safety, workflow, code-style, communication, custom' },
-          },
-          required: ['text'],
-        },
-      },
-      {
-        name: 'list_rules',
-        description: 'List all project rules (active and inactive count).',
-        inputSchema: { type: 'object', properties: {} },
-      },
-      {
-        name: 'remove_rule',
-        description: 'Remove a project rule by ID.',
-        inputSchema: {
-          type: 'object',
-          properties: { rule_id: { type: 'string', description: 'The rule ID to remove' } },
-          required: ['rule_id'],
-        },
-      },
-      {
-        name: 'toggle_rule',
-        description: 'Toggle a rule active/inactive without deleting it.',
-        inputSchema: {
-          type: 'object',
-          properties: { rule_id: { type: 'string', description: 'The rule ID to toggle' } },
-          required: ['rule_id'],
-        },
+        inputSchema: { type: 'object', properties: { level: { type: 'string', enum: ['minimal', 'standard', 'full'], description: 'Guide detail level: "minimal" (~5 rules, saves tokens), "standard" (default, progressive disclosure), "full" (all rules + tool details)' } } , additionalProperties: false},
       },
+      // get_briefing, lock_file, unlock_file, log_decision, get_decisions, kb_*, progress_*
+      // are included via ...knowledge.definitions and ...safety.definitions
+      // --- Safety tools (from tools/safety.js) ---
+      ...safety.definitions,
+      // --- Hook tools (from tools/hooks.js) ---
+      ...hooks.definitions,
+      // --- Governance tools (from tools/governance.js) ---
+      ...governance.definitions,
+      // declare_dependency, check_dependencies included via ...safety.definitions
+      // get_compressed_history included via ...knowledge.definitions
+      // get_reputation included via ...system.definitions above
+      // suggest_task is included via ...tasks.definitions above
+      // Rules, audit, and push tools are included via ...governance.definitions above
       // --- Autonomy Engine tools ---
       {
         name: 'get_work',
@@ -6690,6 +7532,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             just_completed: { type: 'string', description: 'What you just finished (for context continuity)' },
             available_skills: { type: 'array', items: { type: 'string' }, description: 'What you are good at (e.g., "backend", "testing", "frontend")' },
           },
+          additionalProperties: false,
         },
       },
       {
@@ -6706,6 +7549,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             learnings: { type: 'string', description: 'What you learned that could help future work' },
           },
           required: ['workflow_id', 'summary', 'verification', 'confidence'],
+          additionalProperties: false,
         },
       },
       {
@@ -6721,6 +7565,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             attempt_number: { type: 'number', description: 'Which retry this is (1, 2, or 3)' },
           },
           required: ['task_or_step', 'what_failed', 'why_it_failed', 'new_approach'],
+          additionalProperties: false,
         },
       },
       {
@@ -6747,6 +7592,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             parallel: { type: 'boolean', description: 'Allow parallel execution of independent steps (default: true)' },
           },
           required: ['name', 'steps'],
+          additionalProperties: false,
         },
       },
       {
@@ -6758,6 +7604,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             content: { type: 'string', description: 'The user request or prompt to distribute' },
           },
           required: ['content'],
+          additionalProperties: false,
         },
       },
       // --- Managed mode tools ---
@@ -6767,6 +7614,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         inputSchema: {
           type: 'object',
           properties: {},
+          additionalProperties: false,
         },
       },
       {
@@ -6779,6 +7627,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             prompt: { type: 'string', description: 'Optional question or topic for the agent to respond to' },
           },
           required: ['to'],
+          additionalProperties: false,
         },
       },
       {
@@ -6790,6 +7639,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             phase: { type: 'string', description: 'Phase name', enum: ['discussion', 'planning', 'execution', 'review'] },
           },
           required: ['phase'],
+          additionalProperties: false,
         },
       },
     ],
@@ -6798,19 +7648,79 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
+  const startTime = Date.now();
 
   try {
+    // 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']);
+    if (listenExemptTools.has(name)) {
+      if (name === 'listen' || name === 'wait_for_reply') {
+        consecutiveNonListenCalls = 0;
+      }
+    } else if (registeredName) {
+      // Exempt Coordinator (lead role) from listen() blocking — in "responsive" mode
+      // Coordinators use check_messages/consume_messages instead of listen()
+      const isCoordinatorExempt = (() => {
+        try {
+          const profiles = getProfiles();
+          const myProfile = profiles[registeredName];
+          if (myProfile && myProfile.role === 'lead') {
+            const coordMode = (getConfig().coordinator_mode || 'responsive');
+            return coordMode === 'responsive';
+          }
+        } catch (_) { /* fall through */ }
+        return false;
+      })();
+
+      if (!isCoordinatorExempt) {
+        consecutiveNonListenCalls++;
+        if (consecutiveNonListenCalls >= 5) {
+          const coordinator = (() => {
+            try {
+              const profs = getProfiles();
+              const lead = Object.entries(profs).find(([, p]) => p.role === 'lead' || p.role === 'Coordinator');
+              return lead ? lead[0] : 'your coordinator';
+            } catch { return 'your coordinator'; }
+          })();
+          return {
+            content: [{ type: 'text', text: JSON.stringify({
+              error: `BLOCKED: You must call listen() before using other tools. You have made ${consecutiveNonListenCalls} tool calls without listening. Call listen() now.`,
+              blocked_tool: name,
+              calls_without_listen: consecutiveNonListenCalls,
+              fix: `1. Call send_message(to='${coordinator}', content='BLOCKED: I made ${consecutiveNonListenCalls} tool calls without listen(). I was trying to call ${name}. Requesting instructions — should I proceed?') 2. Then call listen() immediately to unblock all tools.`,
+              _listen: 'After send_message(), call listen() immediately. It will reset the counter and unblock all tools.',
+            }, null, 2) }],
+            isError: true,
+          };
+        }
+      }
+    }
+
+    // Middleware: deterministic agent status tracking before each tool call
+    if (registeredName) {
+      const _listenTools = new Set(['listen', 'wait_for_reply']);
+      const _agents = getAgents();
+      if (_agents[registeredName]) {
+        _agents[registeredName].status = _listenTools.has(name) ? 'listening' : 'working';
+        _agents[registeredName].current_tool = name;
+        _agents[registeredName].last_activity = new Date().toISOString();
+        saveAgents(_agents);
+      }
+    }
+
     let result;
 
     switch (name) {
       case 'register':
-        result = toolRegister(args.name, args?.provider);
+        result = toolRegister(args.name, args?.provider, args?.skills);
         break;
       case 'list_agents':
         result = toolListAgents();
         break;
       case 'send_message':
-        result = await toolSendMessage(args.content, args?.to, args?.reply_to, args?.channel);
+        result = await toolSendMessage(args.content, args?.to, args?.reply_to, args?.channel, args?.priority);
         break;
       case 'wait_for_reply':
         result = await toolWaitForReply(args?.timeout_seconds, args?.from);
@@ -6819,28 +7729,31 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         result = toolBroadcast(args.content);
         break;
       case 'listen':
-        result = await toolListen(args?.from);
-        break;
-      case 'listen_codex':
-        result = await toolListenCodex(args?.from);
-        break;
-      case 'check_messages':
-        result = toolCheckMessages(args?.from);
+        result = await toolListen(args?.from, args?.outcome, args?.task_id, args?.summary, args?.mode);
         break;
-      case 'ack_message':
-        result = toolAckMessage(args.message_id);
-        break;
-      case 'get_history':
-        result = toolGetHistory(args?.limit, args?.thread_id);
+      case 'messages': {
+        // Unified message management — routes by action param
+        const action = (args || {}).action;
+        const actionMap = {
+          check: 'check_messages',
+          consume: 'consume_messages',
+          history: 'get_history',
+          search: 'search_messages',
+          ack: 'ack_message',
+          notifications: 'get_notifications',
+        };
+        const target = actionMap[action];
+        if (!target) {
+          result = { error: `Unknown action "${action}". Must be one of: check, consume, history, search, ack, notifications` };
+        } else {
+          result = messaging.handlers[target](args || {});
+        }
         break;
+      }
       case 'create_task':
-        result = toolCreateTask(args.title, args?.description, args?.assignee);
-        break;
       case 'update_task':
-        result = toolUpdateTask(args.task_id, args.status, args?.notes);
-        break;
       case 'list_tasks':
-        result = toolListTasks(args?.status, args?.assignee);
+        result = tasks.handlers[name](args || {});
         break;
       case 'handoff':
         result = toolHandoff(args.to, args.context);
@@ -6849,34 +7762,30 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         result = toolShareFile(args.file_path, args?.to, args?.summary);
         break;
       case 'get_summary':
-        result = toolGetSummary(args?.last_n);
-        break;
-      case 'search_messages':
-        result = toolSearchMessages(args.query, args?.from, args?.limit);
+      case 'get_briefing':
+      case 'log_decision':
+      case 'get_decisions':
+      case 'kb_write':
+      case 'kb_read':
+      case 'kb_list':
+      case 'update_progress':
+      case 'get_progress':
+      case 'get_compressed_history':
+        result = knowledge.handlers[name](args || {});
         break;
       case 'reset':
         result = toolReset();
         break;
       case 'update_profile':
-        result = toolUpdateProfile(args?.display_name, args?.avatar, args?.bio, args?.role);
-        break;
       case 'workspace_write':
-        result = toolWorkspaceWrite(args.key, args.content);
-        break;
       case 'workspace_read':
-        result = toolWorkspaceRead(args?.key, args?.agent);
-        break;
       case 'workspace_list':
-        result = toolWorkspaceList(args?.agent);
+        result = system.handlers[name](args || {});
         break;
       case 'create_workflow':
-        result = toolCreateWorkflow(args.name, args.steps, args?.autonomous, args?.parallel);
-        break;
       case 'advance_workflow':
-        result = toolAdvanceWorkflow(args.workflow_id, args?.notes);
-        break;
       case 'workflow_status':
-        result = toolWorkflowStatus(args?.workflow_id);
+        result = workflows.handlers[name](args || {});
         break;
       case 'fork_conversation':
         result = toolForkConversation(args?.from_message_id, args.branch_name);
@@ -6885,97 +7794,68 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         result = toolSwitchBranch(args.branch_name);
         break;
       case 'list_branches':
-        result = toolListBranches();
+        result = system.handlers[name](args || {});
         break;
       case 'set_conversation_mode':
         result = toolSetConversationMode(args.mode);
         break;
-      case 'listen_group':
-        result = await toolListenGroup();
-        break;
       case 'join_channel':
-        result = toolJoinChannel(args.name, args?.description, args?.rate_limit);
-        break;
       case 'leave_channel':
-        result = toolLeaveChannel(args.name);
-        break;
       case 'list_channels':
-        result = toolListChannels();
+        result = channels.handlers[name](args || {});
         break;
       case 'get_guide':
         result = toolGetGuide(args?.level);
         break;
-      case 'get_briefing':
-        result = toolGetBriefing();
-        break;
+      // get_briefing, log_decision, get_decisions, kb_*, progress_* handled by knowledge module above
       case 'lock_file':
-        result = toolLockFile(args.file_path);
-        break;
       case 'unlock_file':
-        result = toolUnlockFile(args?.file_path);
-        break;
-      case 'log_decision':
-        result = toolLogDecision(args.decision, args?.reasoning, args?.topic);
-        break;
-      case 'get_decisions':
-        result = toolGetDecisions(args?.topic);
-        break;
-      case 'kb_write':
-        result = toolKBWrite(args.key, args.content);
-        break;
-      case 'kb_read':
-        result = toolKBRead(args?.key);
-        break;
-      case 'kb_list':
-        result = toolKBList();
-        break;
-      case 'update_progress':
-        result = toolUpdateProgress(args.feature, args.percent, args?.notes);
-        break;
-      case 'get_progress':
-        result = toolGetProgress();
+      case 'declare_dependency':
+      case 'check_dependencies':
+        result = safety.handlers[name](args || {});
         break;
       case 'call_vote':
-        result = toolCallVote(args.question, args.options);
-        break;
       case 'cast_vote':
-        result = toolCastVote(args.vote_id, args.choice);
-        break;
       case 'vote_status':
-        result = toolVoteStatus(args?.vote_id);
-        break;
       case 'request_review':
-        result = toolRequestReview(args.file_path, args?.description);
-        break;
       case 'submit_review':
-        result = toolSubmitReview(args.review_id, args.status, args?.feedback);
-        break;
-      case 'declare_dependency':
-        result = toolDeclareDependency(args.task_id, args.depends_on);
-        break;
-      case 'check_dependencies':
-        result = toolCheckDependencies(args?.task_id);
-        break;
-      case 'get_compressed_history':
-        result = toolGetCompressedHistory();
+        // Route through governance module
+        if (governance.handlers[name]) {
+          result = governance.handlers[name](args || {});
+        } else {
+          result = { error: `Unknown governance tool: ${name}` };
+        }
         break;
+      // declare_dependency, check_dependencies handled by safety module above
+      // get_compressed_history handled by knowledge module above
       case 'get_reputation':
-        result = toolGetReputation(args?.agent);
+        result = system.handlers[name](args || {});
+        break;
+      case 'subscribe_hook':
+      case 'unsubscribe_hook':
+      case 'list_hooks':
+        result = hooks.handlers[name](args || {});
         break;
       case 'suggest_task':
-        result = toolSuggestTask();
+        result = tasks.handlers[name](args || {});
         break;
       case 'add_rule':
-        result = toolAddRule(args.text, args.category);
-        break;
       case 'list_rules':
-        result = toolListRules();
-        break;
       case 'remove_rule':
-        result = toolRemoveRule(args.rule_id);
-        break;
       case 'toggle_rule':
-        result = toolToggleRule(args.rule_id);
+      case 'log_violation':
+      case 'request_push_approval':
+      case 'ack_push':
+        // Route all governance tools through the module
+        if (governance.handlers[name]) {
+          result = governance.handlers[name](args || {});
+          // Push auto-approve timer
+          if (name === 'request_push_approval' && result.request_id) {
+            setTimeout(() => governance.checkPushAutoApprove(result.request_id), governance.PUSH_AUTO_APPROVE_MS + 1000);
+          }
+        } else {
+          result = { error: `Unknown governance tool: ${name}` };
+        }
         break;
       case 'get_work':
         result = await toolGetWork(args || {});
@@ -7028,7 +7908,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 
     // Global hook: on non-listen tools, check for pending messages and nudge with escalating urgency
     // Enhanced nudge: includes sender names, addressed count, and message preview
-    const listenTools = ['listen', 'listen_group', 'listen_codex', 'wait_for_reply', 'check_messages'];
+    const listenTools = ['listen', 'wait_for_reply'];
     if (registeredName && !listenTools.includes(name) && (isGroupMode() || isManagedMode())) {
       try {
         const pending = getUnconsumedMessages(registeredName);
@@ -7064,7 +7944,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             result._nudge = `${pending.length} messages waiting${addressedHint}: ${senderSummary}. Latest: "${preview}...". Call listen_group().`;
           }
         }
-      } catch {}
+      } catch (e) { log.debug("nudge detection failed:", e.message); }
     }
 
     // Global hook: reputation tracking
@@ -7094,10 +7974,65 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       try { autoCompress(); } catch (e) { log.debug('auto-compress failed:', e.message); }
     }
 
+    // Coordinator mode hint: inject into every tool response for lead/manager/coordinator agents
+    if (registeredName && typeof result === 'object' && result !== null) {
+      try {
+        const prof = getProfiles()[registeredName];
+        const role = prof && prof.role ? prof.role.toLowerCase() : '';
+        if (role === 'lead' || role === 'manager' || role === 'coordinator') {
+          const coordMode = getConfig().coordinator_mode || 'responsive';
+          result.coordinator_mode = coordMode;
+          result.coordinator_hint = coordMode === 'responsive'
+            ? 'MODE: Stay with me — do NOT call listen(). Use consume_messages/workflow_status between human interactions.'
+            : 'MODE: Run autonomously — use listen() to wait for agent results.';
+        }
+      } catch (e) { log.debug('coordinator mode hint failed:', e.message); }
+    }
+
+    // Unread message hint: check if agent has pending messages on every tool call
+    // This ensures agents see messages even when they forget to call listen()
+    if (registeredName && typeof result === 'object' && result !== null && !listenTools.includes(name)) {
+      try {
+        const unread = getUnconsumedMessages(registeredName);
+        if (unread.length > 0) {
+          const latest = unread[unread.length - 1];
+          result.unread_messages = unread.length;
+          result.unread_preview = `${latest.from}: "${latest.content.substring(0, 100).replace(/\n/g, ' ')}"`;
+          result.unread_action = `You have ${unread.length} unread message(s). Call listen() to receive them.`;
+        }
+      } catch (e) { log.debug('unread message hint failed:', e.message); }
+    }
+
+    // Persistent listen() reminder — injected into EVERY non-listen tool response.
+    // Keeps the instruction in the agent's immediate context even after extended
+    // processing pushes earlier instructions out of working memory.
+    if (registeredName && typeof result === 'object' && result !== null && !listenTools.includes(name)) {
+      if (consecutiveNonListenCalls >= 3) {
+        result._listen = `WARNING: You have NOT called listen() in ${consecutiveNonListenCalls} tool calls. Tools will be BLOCKED at 5. Call listen() NOW.`;
+      } else {
+        result._listen = 'After processing this result, call listen() to receive messages. Do NOT skip this.';
+      }
+    }
+
+    // Log successful tool call
+    const duration = Date.now() - startTime;
+    _audit.logToolCall(registeredName, name, args, result, duration, {
+      session_id: `sess_${process.pid}`,
+      branch: currentBranch || 'main'
+    });
+
     return {
       content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
     };
   } catch (error) {
+    // Log failed tool call
+    const duration = Date.now() - startTime;
+    const errorResult = { error: error.message };
+    _audit.logToolCall(registeredName, name, args, errorResult, duration, {
+      session_id: `sess_${process.pid}`,
+      branch: currentBranch || 'main'
+    });
+
     return {
       content: [{ type: 'text', text: `Error: ${error.message}` }],
       isError: true,
@@ -7153,6 +8088,60 @@ process.on('exit', () => {
 process.on('SIGTERM', () => process.exit(0));
 process.on('SIGINT', () => process.exit(0));
 
+/**
+ * Auto-reclaim a dead agent's identity on MCP process startup.
+ * Scans agents.json for entries whose PID is dead, picks the most recently
+ * active one, updates its PID to the current process, and restarts heartbeat.
+ * Avoids the need for an explicit register() call on session reconnect.
+ */
+function autoReclaimDeadSeat() {
+  try {
+    if (!fs.existsSync(AGENTS_FILE)) return;
+    const agents = JSON.parse(fs.readFileSync(AGENTS_FILE, 'utf8'));
+    let bestName = null;
+    let bestTime = 0;
+
+    for (const [name, entry] of Object.entries(agents)) {
+      if (!entry || !entry.pid) continue;
+      let alive = false;
+      try { process.kill(entry.pid, 0); alive = true; } catch {}
+      if (alive) continue;
+
+      const hbFile = heartbeatFile(name);
+      let lastActivity = entry.last_activity;
+      try {
+        const hb = JSON.parse(fs.readFileSync(hbFile, 'utf8'));
+        if (hb.last_activity) lastActivity = hb.last_activity;
+      } catch {}
+
+      const ts = lastActivity ? new Date(lastActivity).getTime() : 0;
+      if (ts > bestTime) {
+        bestTime = ts;
+        bestName = name;
+      }
+    }
+
+    if (!bestName) return;
+
+    const now = new Date().toISOString();
+    agents[bestName].pid = process.pid;
+    agents[bestName].ppid = process.ppid;
+    agents[bestName].last_activity = now;
+    saveAgents(agents);
+    registeredName = bestName;
+    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
+    if (heartbeatInterval) clearInterval(heartbeatInterval);
+    heartbeatInterval = setInterval(() => { touchHeartbeat(registeredName); }, 10000);
+    heartbeatInterval.unref();
+    console.error(`[neohive] Auto-reclaimed seat "${bestName}" (previous PID dead)`);
+  } catch (e) {
+    console.error('[neohive] Auto-reclaim failed:', e.message);
+  }
+}
+
 async function main() {
   try {
     ensureDataDir();
@@ -7161,14 +8150,154 @@ async function main() {
     console.error('Fix: Run "npx neohive doctor" to diagnose the issue.');
     process.exit(1);
   }
-  try {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error('Neohive MCP server v6.0.0 running (66 tools)');
-  } catch (e) {
-    console.error('ERROR: MCP server failed to start: ' + e.message);
-    console.error('Fix: Run "npx neohive doctor" to check your setup.');
-    process.exit(1);
+
+  // HTTP persistent server mode: --http flag or NEOHIVE_TRANSPORT=http
+  const useHttp = process.argv.includes('--http') || process.env.NEOHIVE_TRANSPORT === 'http';
+
+  if (useHttp) {
+    try {
+      const http = require('http');
+      const { randomUUID } = require('crypto');
+      const { StreamableHTTPServerTransport } = require('@modelcontextprotocol/sdk/server/streamableHttp.js');
+      const { isInitializeRequest } = require('@modelcontextprotocol/sdk/types.js');
+
+      const PORT = parseInt(process.env.NEOHIVE_SERVER_PORT || '4321', 10);
+      const sessions = {};
+
+      const httpServer = http.createServer(async (req, res) => {
+        // CORS headers for local dev
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, mcp-session-id');
+        res.setHeader('Access-Control-Expose-Headers', 'mcp-session-id');
+
+        if (req.method === 'OPTIONS') {
+          res.writeHead(204);
+          res.end();
+          return;
+        }
+
+        // Health check endpoint
+        if (req.url === '/health') {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ status: 'ok', sessions: Object.keys(sessions).length }));
+          return;
+        }
+
+        if (req.url === '/mcp') {
+          if (req.method === 'POST') {
+            // Parse JSON body
+            let body = '';
+            for await (const chunk of req) body += chunk;
+            let parsed;
+            try { parsed = JSON.parse(body); } catch {
+              res.writeHead(400, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ jsonrpc: '2.0', error: { code: -32700, message: 'Parse error' }, id: null }));
+              return;
+            }
+
+            const sessionId = req.headers['mcp-session-id'];
+
+            if (sessionId && sessions[sessionId]) {
+              // Existing session — route to its transport
+              await sessions[sessionId].transport.handleRequest(req, res, parsed);
+            } else if (!sessionId && isInitializeRequest(parsed)) {
+              // New session initialization
+              const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: () => randomUUID(),
+                onsessioninitialized: (sid) => {
+                  sessions[sid] = { transport, createdAt: Date.now() };
+                  console.error(`[HTTP] Session created: ${sid}`);
+                },
+              });
+
+              transport.onclose = () => {
+                const sid = transport.sessionId;
+                if (sid && sessions[sid]) {
+                  delete sessions[sid];
+                  console.error(`[HTTP] Session closed: ${sid}`);
+                }
+              };
+
+              await server.connect(transport);
+              await transport.handleRequest(req, res, parsed);
+            } else {
+              res.writeHead(400, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ jsonrpc: '2.0', error: { code: -32000, message: 'Bad Request: No valid session ID' }, id: null }));
+            }
+          } else if (req.method === 'GET') {
+            // SSE stream for server-initiated notifications
+            const sessionId = req.headers['mcp-session-id'];
+            if (sessionId && sessions[sessionId]) {
+              await sessions[sessionId].transport.handleRequest(req, res);
+            } else {
+              res.writeHead(400, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ error: 'Missing or invalid session ID' }));
+            }
+          } else if (req.method === 'DELETE') {
+            // Session termination
+            const sessionId = req.headers['mcp-session-id'];
+            if (sessionId && sessions[sessionId]) {
+              await sessions[sessionId].transport.close();
+              delete sessions[sessionId];
+              res.writeHead(200, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ success: true }));
+            } else {
+              res.writeHead(404, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ error: 'Session not found' }));
+            }
+          } else {
+            res.writeHead(405, { Allow: 'GET, POST, DELETE' });
+            res.end('Method Not Allowed');
+          }
+        } else {
+          res.writeHead(404);
+          res.end('Not Found');
+        }
+      });
+
+      httpServer.on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+          console.error(`ERROR: Port ${PORT} is already in use.`);
+          console.error(`Another neohive HTTP server may be running. Try:`);
+          console.error(`  kill $(lsof -ti :${PORT})  # free the port`);
+          console.error(`  NEOHIVE_SERVER_PORT=4322 npx neohive serve  # use different port`);
+          process.exit(1);
+        }
+        throw err;
+      });
+
+      httpServer.listen(PORT, () => {
+        console.error(`Neohive MCP server v6.0.0 running in HTTP mode on port ${PORT}`);
+        console.error(`Endpoint: http://localhost:${PORT}/mcp`);
+        console.error(`Health: http://localhost:${PORT}/health`);
+      });
+
+      // Graceful shutdown
+      process.on('SIGINT', () => {
+        console.error('\n[HTTP] Shutting down...');
+        for (const sid of Object.keys(sessions)) {
+          try { sessions[sid].transport.close(); } catch {}
+        }
+        httpServer.close(() => process.exit(0));
+      });
+    } catch (e) {
+      console.error('ERROR: HTTP server failed to start: ' + e.message);
+      console.error('Fix: Ensure @modelcontextprotocol/sdk is up to date.');
+      process.exit(1);
+    }
+  } else {
+    // Default: stdio transport (one agent per process)
+    try {
+      autoReclaimDeadSeat();
+      startStdinActivityTracker();
+      const transport = new StdioServerTransport();
+      await server.connect(transport);
+    } catch (e) {
+      console.error('ERROR: MCP server failed to start: ' + e.message);
+      console.error('Fix: Run "npx neohive doctor" to check your setup.');
+      process.exit(1);
+    }
   }
 }