nothumanallowed 5.0.0 → 6.0.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nothumanallowed",
-  "version": "5.0.0",
-  "description": "NotHumanAllowed — 38 AI agents for security, code, DevOps, data & daily ops. Ask agents directly, plan your day with 5 specialist agents, manage tasks, connect Gmail + Calendar.",
+  "version": "6.0.1",
+  "description": "NotHumanAllowed — 38 AI agents for security, code, DevOps, data & daily ops. Per-agent memory, Telegram + Discord auto-responder, proactive intelligence daemon, voice chat, plugin system.",
   "type": "module",
   "bin": {
     "nha": "./bin/nha.mjs",
@@ -31,7 +31,14 @@
     "anthropic",
     "openai",
     "gemini",
-    "deepseek"
+    "deepseek",
+    "telegram-bot",
+    "discord-bot",
+    "voice-assistant",
+    "daily-ops",
+    "gmail",
+    "calendar",
+    "proactive"
   ],
   "author": "Nicola Cucurachi <ados.labsproject@gmail.com>",
   "license": "MIT",

package/src/cli.mjs

@@ -12,6 +12,7 @@ import { cmdAsk } from './commands/ask.mjs';
 import { cmdPlan } from './commands/plan.mjs';
 import { cmdTasks } from './commands/tasks.mjs';
 import { cmdOps } from './commands/ops.mjs';
+import { cmdAutostart } from './commands/autostart.mjs';
 import { cmdChat } from './commands/chat.mjs';
 import { cmdUI } from './commands/ui.mjs';
 import { cmdGoogle } from './commands/google-auth.mjs';
@@ -60,6 +61,12 @@ export async function main(argv) {
     case 'ops':
       return cmdOps(args);
 
+    case 'autostart':
+      return cmdAutostart(args);
+
+    case 'responder':
+      return cmdResponder(args);
+
     case 'chat':
       return cmdChat(args);
 
@@ -131,6 +138,73 @@ export async function main(argv) {
   }
 }
 
+// ── nha responder ─────────────────────────────────────────────────────────
+async function cmdResponder(args) {
+  const sub = args[0] || 'status';
+  const config = loadConfig();
+
+  switch (sub) {
+    case 'start': {
+      const { isRunning } = await import('./services/ops-daemon.mjs');
+      if (!isRunning()) {
+        warn('Daemon is not running. The responder runs inside the daemon.');
+        info('Start it with: nha ops start');
+        info('Or enable autostart: nha autostart enable');
+        return;
+      }
+      info('The responder starts automatically with the daemon when tokens are configured.');
+      info('Configure tokens:');
+      console.log('  nha config set telegram-bot-token YOUR_BOT_TOKEN');
+      console.log('  nha config set discord-bot-token YOUR_BOT_TOKEN');
+      info('Then restart the daemon: nha ops stop && nha ops start');
+      return;
+    }
+
+    case 'stop': {
+      info('The responder stops when the daemon stops.');
+      info('Run: nha ops stop');
+      return;
+    }
+
+    case 'status': {
+      console.log(`\n  ${BOLD}Message Responder Status${NC}\n`);
+
+      const telegramToken = config.responder?.telegram?.token;
+      const discordToken = config.responder?.discord?.token;
+      const autoRoute = config.responder?.autoRoute !== false;
+
+      console.log(`  Telegram:     ${telegramToken ? G + 'configured' + NC : D + '(not set)' + NC}`);
+      if (telegramToken) {
+        const chatIds = config.responder?.telegram?.allowedChatIds || [];
+        console.log(`    Chat filter: ${chatIds.length > 0 ? Y + chatIds.join(', ') + NC : D + 'all chats' + NC}`);
+      }
+
+      console.log(`  Discord:      ${discordToken ? G + 'configured' + NC : D + '(not set)' + NC}`);
+      if (discordToken) {
+        const channelIds = config.responder?.discord?.allowedChannelIds || [];
+        console.log(`    Channel filter: ${channelIds.length > 0 ? Y + channelIds.join(', ') + NC : D + 'all channels (mention/command only)' + NC}`);
+      }
+
+      console.log(`  Auto-route:   ${autoRoute ? G + 'keyword routing' + NC : D + 'CONDUCTOR only' + NC}`);
+
+      const { isRunning: isDaemonRunning } = await import('./services/ops-daemon.mjs');
+      console.log(`  Daemon:       ${isDaemonRunning() ? G + 'running' + NC : R + 'stopped' + NC}`);
+      console.log('');
+
+      if (!telegramToken && !discordToken) {
+        info('Configure a bot token to enable:');
+        console.log('  nha config set telegram-bot-token YOUR_TOKEN');
+        console.log('  nha config set discord-bot-token YOUR_TOKEN');
+      }
+      return;
+    }
+
+    default:
+      fail(`Unknown: nha responder ${sub}`);
+      info('Commands: start, stop, status');
+  }
+}
+
 // ── nha run ────────────────────────────────────────────────────────────────
 async function cmdRun(args) {
   if (args.length === 0) {
@@ -252,6 +326,8 @@ function cmdConfig(args) {
       info('      verbose, immersive, deliberation, rounds, convergence, tribunal, knowledge');
       info('      google-client-id, google-client-secret');
       info('      microsoft-client-id, microsoft-client-secret, microsoft-tenant');
+      info('      telegram-bot-token, discord-bot-token, responder-auto-route');
+      info('      proactive, proactive-email, proactive-meeting, proactive-patterns, proactive-deadlines');
       return;
     }
     const success = setConfigValue(key, value);
@@ -264,9 +340,8 @@ function cmdConfig(args) {
   }
 
   if (sub === 'reset') {
-    const { saveConfig } = loadConfig; // re-import
     fs.rmSync(path.join(NHA_DIR, 'config.json'), { force: true });
-    ok('Config reset to defaults');
+    ok('Config reset to defaults. Run any command to regenerate.');
     return;
   }
 
@@ -322,6 +397,23 @@ function cmdConfig(args) {
     if (config.voice.language) console.log(`    Language:       ${D}${config.voice.language}${NC}`);
   }
 
+  if (config.responder) {
+    console.log(`\n  ${C}Message Responder${NC}`);
+    console.log(`    Telegram:       ${config.responder.telegram?.token ? G + 'configured' : D + '(not set)'}${NC}`);
+    console.log(`    Discord:        ${config.responder.discord?.token ? G + 'configured' : D + '(not set)'}${NC}`);
+    console.log(`    Auto-route:     ${config.responder.autoRoute !== false ? G + 'yes' : D + 'no'}${NC}`);
+  }
+
+  const proactive = config.ops?.proactive;
+  if (proactive) {
+    console.log(`\n  ${C}Proactive Intelligence${NC}`);
+    console.log(`    Enabled:        ${proactive.enabled !== false ? G + 'yes' : D + 'no'}${NC}`);
+    console.log(`    Email follow-up:${proactive.emailFollowUp !== false ? G + ' on' : D + ' off'}${NC}`);
+    console.log(`    Meeting prep:   ${proactive.meetingPrep !== false ? G + 'on' : D + 'off'}${NC}`);
+    console.log(`    Patterns:       ${proactive.patterns !== false ? G + 'on' : D + 'off'}${NC}`);
+    console.log(`    Deadlines:      ${proactive.deadlines !== false ? G + 'on' : D + 'off'}${NC}`);
+  }
+
   console.log('');
 }
 
@@ -431,7 +523,23 @@ function cmdHelp() {
   console.log(`    tasks week            Week overview`);
   console.log(`    ops start             Start background daemon (auto-alerts + WebSocket)`);
   console.log(`    ops stop              Stop daemon`);
-  console.log(`    ops status            Daemon status\n`);
+  console.log(`    ops status            Daemon status`);
+  console.log(`    autostart enable      Auto-start daemon on login (launchd/systemd)`);
+  console.log(`    autostart disable     Remove OS autostart`);
+  console.log(`    autostart status      Check autostart configuration\n`);
+
+  console.log(`  ${C}Message Responder${NC}  ${D}(Telegram + Discord auto-reply)${NC}`);
+  console.log(`    responder status      Show responder configuration`);
+  console.log(`    config set telegram-bot-token TOKEN`);
+  console.log(`    config set discord-bot-token TOKEN`);
+  console.log(`    ${D}Routes messages to agents via keyword matching (zero LLM overhead)${NC}\n`);
+
+  console.log(`  ${C}Proactive Intelligence${NC}  ${D}(runs inside daemon)${NC}`);
+  console.log(`    ${D}Email follow-ups, meeting prep, pattern detection, deadline tracking${NC}`);
+  console.log(`    config set proactive true/false       Toggle all proactive features`);
+  console.log(`    config set proactive-email true/false  Email follow-up reminders`);
+  console.log(`    config set proactive-meeting true/false  Auto meeting briefs`);
+  console.log(`    config set proactive-deadlines true/false  Deadline alerts\n`);
 
   console.log(`  ${C}Google Integration${NC}`);
   console.log(`    google auth           Connect Gmail + Calendar`);

package/src/commands/autostart.mjs

@@ -0,0 +1,342 @@
+/**
+ * nha autostart — OS-level daemon autostart management.
+ *
+ * macOS:  launchd plist at ~/Library/LaunchAgents/com.nha.daemon.plist
+ * Linux:  systemd user service at ~/.config/systemd/user/nha-daemon.service
+ *
+ * Zero dependencies.
+ */
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { execSync, spawnSync } from 'child_process';
+import { NHA_DIR, DAEMON_SCRIPT } from '../constants.mjs';
+import { info, ok, fail, warn, C, G, Y, D, W, BOLD, NC, R } from '../ui.mjs';
+
+const PLATFORM = os.platform();
+const HOME = os.homedir();
+
+// ── Paths ────────────────────────────────────────────────────────────────────
+
+// DAEMON_SCRIPT is resolved relative to the installed package (via constants.mjs),
+// so it works correctly both in development and after npm install -g.
+const DAEMON_SCRIPT_ABS = DAEMON_SCRIPT;
+const NODE_BIN = process.execPath;
+
+const LAUNCHD_LABEL = 'com.nha.daemon';
+const LAUNCHD_PLIST = path.join(HOME, 'Library', 'LaunchAgents', `${LAUNCHD_LABEL}.plist`);
+const LAUNCHD_LOG_DIR = path.join(NHA_DIR, 'ops', 'daemon');
+
+const SYSTEMD_DIR = path.join(HOME, '.config', 'systemd', 'user');
+const SYSTEMD_UNIT = 'nha-daemon.service';
+const SYSTEMD_FILE = path.join(SYSTEMD_DIR, SYSTEMD_UNIT);
+
+// ── launchd (macOS) ──────────────────────────────────────────────────────────
+
+function generateLaunchdPlist() {
+  // launchd XML plist — KeepAlive restarts on crash, RunAtLoad starts on login
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHD_LABEL}</string>
+
+  <key>ProgramArguments</key>
+  <array>
+    <string>${NODE_BIN}</string>
+    <string>${DAEMON_SCRIPT_ABS}</string>
+    <string>--daemon-loop</string>
+  </array>
+
+  <key>RunAtLoad</key>
+  <true/>
+
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+
+  <key>StandardOutPath</key>
+  <string>${path.join(LAUNCHD_LOG_DIR, 'daemon.log')}</string>
+
+  <key>StandardErrorPath</key>
+  <string>${path.join(LAUNCHD_LOG_DIR, 'daemon.log')}</string>
+
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>NHA_DAEMON</key>
+    <string>1</string>
+    <key>HOME</key>
+    <string>${HOME}</string>
+    <key>PATH</key>
+    <string>/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin:${path.dirname(NODE_BIN)}</string>
+  </dict>
+
+  <key>ProcessType</key>
+  <string>Background</string>
+
+  <key>LowPriorityIO</key>
+  <true/>
+</dict>
+</plist>
+`;
+}
+
+function launchdInstall() {
+  const agentsDir = path.join(HOME, 'Library', 'LaunchAgents');
+  fs.mkdirSync(agentsDir, { recursive: true });
+  fs.mkdirSync(LAUNCHD_LOG_DIR, { recursive: true });
+
+  fs.writeFileSync(LAUNCHD_PLIST, generateLaunchdPlist(), { mode: 0o644 });
+
+  // Load the agent (starts it immediately)
+  const result = spawnSync('launchctl', ['load', '-w', LAUNCHD_PLIST], { encoding: 'utf-8' });
+  if (result.status !== 0) {
+    const stderr = (result.stderr || '').trim();
+    // Already loaded is not a real error
+    if (!stderr.includes('already loaded') && !stderr.includes('service already loaded')) {
+      throw new Error(`launchctl load failed: ${stderr}`);
+    }
+  }
+}
+
+function launchdUninstall() {
+  if (!fs.existsSync(LAUNCHD_PLIST)) {
+    return false;
+  }
+
+  // Unload (stops the daemon)
+  spawnSync('launchctl', ['unload', '-w', LAUNCHD_PLIST], { encoding: 'utf-8' });
+
+  fs.rmSync(LAUNCHD_PLIST, { force: true });
+  return true;
+}
+
+function launchdStatus() {
+  const installed = fs.existsSync(LAUNCHD_PLIST);
+  if (!installed) {
+    return { installed: false, running: false, pid: null };
+  }
+
+  // Check if service is loaded and running
+  const result = spawnSync('launchctl', ['list'], { encoding: 'utf-8' });
+  const lines = (result.stdout || '').split('\n');
+  const match = lines.find(l => l.includes(LAUNCHD_LABEL));
+
+  if (!match) {
+    return { installed: true, running: false, pid: null };
+  }
+
+  // Format: PID Status Label
+  const parts = match.trim().split(/\s+/);
+  const pid = parts[0] === '-' ? null : parseInt(parts[0], 10);
+  const running = pid !== null && !isNaN(pid);
+
+  return { installed: true, running, pid };
+}
+
+// ── systemd (Linux) ──────────────────────────────────────────────────────────
+
+function generateSystemdUnit() {
+  return `[Unit]
+Description=NHA PAO Background Daemon
+Documentation=https://nothumanallowed.com/docs/cli
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${NODE_BIN} ${DAEMON_SCRIPT_ABS} --daemon-loop
+Environment=NHA_DAEMON=1
+Environment=HOME=${HOME}
+Environment=PATH=/usr/local/bin:/usr/bin:/bin:${path.dirname(NODE_BIN)}
+
+Restart=on-failure
+RestartSec=10
+StartLimitIntervalSec=300
+StartLimitBurst=5
+
+StandardOutput=append:${path.join(LAUNCHD_LOG_DIR, 'daemon.log')}
+StandardError=append:${path.join(LAUNCHD_LOG_DIR, 'daemon.log')}
+
+# Security hardening
+NoNewPrivileges=true
+ProtectSystem=strict
+ProtectHome=read-only
+ReadWritePaths=${NHA_DIR}
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+function systemdInstall() {
+  fs.mkdirSync(SYSTEMD_DIR, { recursive: true });
+  fs.mkdirSync(LAUNCHD_LOG_DIR, { recursive: true });
+
+  fs.writeFileSync(SYSTEMD_FILE, generateSystemdUnit(), { mode: 0o644 });
+
+  // Reload systemd user daemon to pick up new unit
+  spawnSync('systemctl', ['--user', 'daemon-reload'], { encoding: 'utf-8' });
+
+  // Enable (auto-start on login) and start immediately
+  const enableResult = spawnSync('systemctl', ['--user', 'enable', '--now', SYSTEMD_UNIT], {
+    encoding: 'utf-8',
+  });
+
+  if (enableResult.status !== 0) {
+    const stderr = (enableResult.stderr || '').trim();
+    throw new Error(`systemctl enable failed: ${stderr}`);
+  }
+
+  // Enable lingering so the user service runs even when not logged in (optional, best-effort)
+  spawnSync('loginctl', ['enable-linger', os.userInfo().username], { encoding: 'utf-8' });
+}
+
+function systemdUninstall() {
+  if (!fs.existsSync(SYSTEMD_FILE)) {
+    return false;
+  }
+
+  // Stop and disable
+  spawnSync('systemctl', ['--user', 'disable', '--now', SYSTEMD_UNIT], { encoding: 'utf-8' });
+
+  fs.rmSync(SYSTEMD_FILE, { force: true });
+
+  // Reload to clean up
+  spawnSync('systemctl', ['--user', 'daemon-reload'], { encoding: 'utf-8' });
+
+  return true;
+}
+
+function systemdStatus() {
+  const installed = fs.existsSync(SYSTEMD_FILE);
+  if (!installed) {
+    return { installed: false, running: false, pid: null };
+  }
+
+  const result = spawnSync('systemctl', ['--user', 'is-active', SYSTEMD_UNIT], {
+    encoding: 'utf-8',
+  });
+  const active = (result.stdout || '').trim() === 'active';
+
+  let pid = null;
+  if (active) {
+    const showResult = spawnSync('systemctl', ['--user', 'show', SYSTEMD_UNIT, '--property=MainPID'], {
+      encoding: 'utf-8',
+    });
+    const pidMatch = (showResult.stdout || '').match(/MainPID=(\d+)/);
+    if (pidMatch) pid = parseInt(pidMatch[1], 10);
+  }
+
+  return { installed: true, running: active, pid };
+}
+
+// ── Platform Dispatcher ──────────────────────────────────────────────────────
+
+function getPlatformAdapter() {
+  if (PLATFORM === 'darwin') {
+    return { install: launchdInstall, uninstall: launchdUninstall, status: launchdStatus, name: 'launchd' };
+  }
+  if (PLATFORM === 'linux') {
+    return { install: systemdInstall, uninstall: systemdUninstall, status: systemdStatus, name: 'systemd' };
+  }
+  return null;
+}
+
+// ── Command Handler ──────────────────────────────────────────────────────────
+
+export async function cmdAutostart(args) {
+  const sub = args[0] || 'status';
+  const adapter = getPlatformAdapter();
+
+  if (!adapter) {
+    fail(`Autostart is not supported on ${PLATFORM}`);
+    info('Supported platforms: macOS (launchd), Linux (systemd)');
+    return;
+  }
+
+  switch (sub) {
+    case 'enable': {
+      // Verify the daemon script exists
+      if (!fs.existsSync(DAEMON_SCRIPT_ABS)) {
+        fail(`Daemon script not found at: ${DAEMON_SCRIPT_ABS}`);
+        info('Run "nha update" to re-download core files.');
+        return;
+      }
+
+      const currentStatus = adapter.status();
+      if (currentStatus.installed && currentStatus.running) {
+        warn('Autostart is already enabled and running.');
+        return;
+      }
+
+      try {
+        adapter.install();
+        const newStatus = adapter.status();
+        ok(`Autostart enabled via ${adapter.name}`);
+        if (newStatus.running) {
+          ok(`Daemon started (PID ${newStatus.pid})`);
+        } else {
+          info('Daemon will start on next login.');
+        }
+
+        if (adapter.name === 'launchd') {
+          info(`Plist: ${LAUNCHD_PLIST}`);
+        } else {
+          info(`Unit: ${SYSTEMD_FILE}`);
+        }
+        info('The daemon auto-restarts on crash (10s cooldown).');
+      } catch (err) {
+        fail(`Failed to enable autostart: ${err.message}`);
+      }
+      return;
+    }
+
+    case 'disable': {
+      try {
+        const removed = adapter.uninstall();
+        if (removed) {
+          ok('Autostart disabled. Daemon stopped and service removed.');
+        } else {
+          warn('Autostart was not enabled.');
+        }
+      } catch (err) {
+        fail(`Failed to disable autostart: ${err.message}`);
+      }
+      return;
+    }
+
+    case 'status': {
+      const status = adapter.status();
+      console.log(`\n  ${BOLD}Autostart Status${NC}  ${D}(${adapter.name})${NC}\n`);
+      console.log(`  Installed:   ${status.installed ? G + 'yes' + NC : D + 'no' + NC}`);
+      console.log(`  Running:     ${status.running ? G + 'yes' + NC + (status.pid ? ` (PID ${status.pid})` : '') : R + 'no' + NC}`);
+
+      if (adapter.name === 'launchd') {
+        console.log(`  Plist:       ${D}${LAUNCHD_PLIST}${NC}`);
+      } else {
+        console.log(`  Unit:        ${D}${SYSTEMD_FILE}${NC}`);
+      }
+
+      console.log(`  Daemon:      ${D}${DAEMON_SCRIPT_ABS}${NC}`);
+      console.log(`  Node:        ${D}${NODE_BIN}${NC}`);
+      console.log('');
+
+      if (!status.installed) {
+        info('Enable with: nha autostart enable');
+      }
+      return;
+    }
+
+    default:
+      fail(`Unknown: nha autostart ${sub}`);
+      info('Commands: enable, disable, status');
+  }
+}

package/src/commands/chat.mjs

@@ -11,6 +11,7 @@
 import readline from 'readline';
 import { loadConfig } from '../config.mjs';
 import { callLLM } from '../services/llm.mjs';
+import { loadChatHistory, saveChatHistory, extractMemory } from '../services/memory.mjs';
 import { fail, info, ok, warn, C, G, Y, D, W, BOLD, NC, M, R, B } from '../ui.mjs';
 
 // ── Mail + Calendar imports (unified router — Google or Microsoft) ───────────
@@ -493,8 +494,9 @@ async function handleSlashCommand(input, config, history) {
 
   if (trimmed === '/clear') {
     history.length = 0;
+    try { saveChatHistory([]); } catch { /* non-critical */ }
     console.clear();
-    console.log(`  ${G}Conversation cleared.${NC}`);
+    console.log(`  ${G}Conversation cleared (memory preserved, chat history reset).${NC}`);
     return true;
   }
 
@@ -582,7 +584,11 @@ export async function cmdChat(args) {
     terminal: true,
   });
 
-  const history = [];
+  // Load persisted chat history from previous sessions
+  const history = loadChatHistory();
+  if (history.length > 0) {
+    ok(`Loaded ${Math.floor(history.length / 2)} previous conversation turns from memory.`);
+  }
   const systemPrompt = buildSystemPrompt(initialContext);
 
   // ── Graceful exit ───────────────────────────────────────────────────────
@@ -695,6 +701,10 @@ export async function cmdChat(args) {
         history.shift();
         history.shift();
       }
+
+      // Persist chat history and extract episodic memory
+      try { saveChatHistory(history); } catch { /* non-critical */ }
+      try { extractMemory('chat', input, response); } catch { /* non-critical */ }
     } catch (err) {
       process.stdout.write('\r' + ' '.repeat(40) + '\r');
       console.log(`\n  ${R}LLM error: ${err.message}${NC}\n`);

package/src/commands/ops.mjs

@@ -17,6 +17,20 @@ export async function cmdOps(args) {
       if (result.ok) {
         ok(`PAO daemon started (PID ${result.pid})`);
         info('Monitoring Gmail + Calendar. Notifications enabled.');
+
+        const config = loadConfig();
+        const hasTelegram = !!config.responder?.telegram?.token;
+        const hasDiscord = !!config.responder?.discord?.token;
+        if (hasTelegram || hasDiscord) {
+          const platforms = [hasTelegram && 'Telegram', hasDiscord && 'Discord'].filter(Boolean).join(' + ');
+          info(`Message responder active: ${platforms}`);
+        }
+
+        const proactive = config.ops?.proactive?.enabled !== false;
+        if (proactive) {
+          info('Proactive intelligence enabled (follow-ups, meeting prep, deadlines).');
+        }
+
         info('Run "nha ops status" to check. "nha ops stop" to halt.');
       } else {
         warn(result.message);
@@ -36,6 +50,8 @@ export async function cmdOps(args) {
 
     case 'status': {
       const status = getDaemonStatus();
+      const config = loadConfig();
+
       console.log(`\n  ${BOLD}PAO Daemon Status${NC}\n`);
       console.log(`  Running:          ${status.running ? G + 'yes' + NC + ` (PID ${status.pid})` : R + 'no' + NC}`);
       if (status.startedAt) console.log(`  Started:          ${D}${status.startedAt}${NC}`);
@@ -43,6 +59,27 @@ export async function cmdOps(args) {
       if (status.lastCalendarCheck) console.log(`  Last cal check:   ${D}${status.lastCalendarCheck}${NC}`);
       if (status.lastPlanGenerated) console.log(`  Last plan:        ${D}${status.lastPlanGenerated}${NC}`);
       if (status.errors > 0) console.log(`  Errors:           ${Y}${status.errors}${NC}`);
+
+      // Proactive Intelligence Engine status
+      const proactive = status.proactive || {};
+      console.log(`\n  ${BOLD}Proactive Intelligence${NC}\n`);
+      console.log(`  Enabled:          ${proactive.enabled !== false ? G + 'yes' + NC : D + 'no' + NC}`);
+      console.log(`  Email follow-up:  ${proactive.emailFollowUp !== false ? G + 'on' + NC : D + 'off' + NC}`);
+      console.log(`  Meeting prep:     ${proactive.meetingPrep !== false ? G + 'on' + NC : D + 'off' + NC}`);
+      console.log(`  Pattern detect:   ${proactive.patterns !== false ? G + 'on' + NC : D + 'off' + NC}`);
+      console.log(`  Deadline alerts:  ${proactive.deadlines !== false ? G + 'on' + NC : D + 'off' + NC}`);
+      if (status.lastProactiveCheck) console.log(`  Last check:       ${D}${status.lastProactiveCheck}${NC}`);
+      if (status.lastPatternDetection) console.log(`  Last patterns:    ${D}${status.lastPatternDetection}${NC}`);
+
+      // Message Responder status
+      const responder = status.responder || {};
+      const telegramConfigured = !!config.responder?.telegram?.token;
+      const discordConfigured = !!config.responder?.discord?.token;
+      console.log(`\n  ${BOLD}Message Responder${NC}\n`);
+      console.log(`  Telegram:         ${responder.telegram ? G + 'active' + NC : telegramConfigured ? Y + 'configured (daemon restart needed)' + NC : D + 'not configured' + NC}`);
+      console.log(`  Discord:          ${responder.discord ? G + 'active' + NC : discordConfigured ? Y + 'configured (daemon restart needed)' + NC : D + 'not configured' + NC}`);
+      console.log(`  Auto-route:       ${config.responder?.autoRoute !== false ? G + 'keyword routing' + NC : D + 'CONDUCTOR only' + NC}`);
+
       console.log('');
       return;
     }