ai-control-center 1.15.2

package/lib/twitch/bot.js

@@ -0,0 +1,354 @@
+/**
+ * AI Control Center Twitch Bot — remote pipeline control + notifications.
+ *
+ * Setup:
+ *   1. Create a Twitch application at https://dev.twitch.tv/console
+ *   2. Generate an OAuth access token (chat:read, chat:edit scopes)
+ *   3. Set env vars (prefix with your project prefix from aicc.config.js):
+ *      export {PREFIX}_TWITCH_CHANNEL=your_channel_name
+ *      export {PREFIX}_TWITCH_ACCESS_TOKEN=your_oauth_token
+ *      export {PREFIX}_TWITCH_CLIENT_ID=your_client_id
+ *      export {PREFIX}_TWITCH_CLIENT_SECRET=your_client_secret    (optional, for token refresh)
+ *      export {PREFIX}_TWITCH_ALLOWED_IDS=id1,id2                 (Twitch user IDs — comma-separated)
+ *   4. Run: aicc twitch
+ *
+ * Commands (use ! prefix in chat, e.g. !status):
+ *   !status   — Pipeline status
+ *   !feature  — Start a new feature
+ *   !review   — Run code review
+ *   !deploy   — Deploy
+ *   !approve  — Approve current feature
+ *   !reject   — Reject / request fixes
+ *   !logs     — Show recent logs
+ *   !health   — System health check
+ *   !ai       — Ask the AI a question
+ *
+ * Security:
+ *   - TWITCH_ALLOWED_IDS restricts which Twitch user IDs can use commands.
+ *   - Commands from unauthorized users are silently ignored.
+ *
+ * Rate Limiting:
+ *   - Twitch allows 20 messages per 30 seconds for non-moderator bots.
+ *   - This bot enforces a queue to stay within limits.
+ */
+import https from 'https';
+import { WebSocket } from 'ws';
+import { env, getConfig, loadConfig } from '../config.js';
+import { autoResumePipeline } from '../shared/action-runner.js';
+import { bus } from '../shared/event-bus.js';
+import { registerCommands } from './commands.js';
+import { setupNotifications } from './notifications.js';
+
+// ─── Constants ────────────────────────────────────────────────────────────────
+
+const IRC_URL         = 'wss://irc-ws.chat.twitch.tv:443';
+const MAX_MSG_LENGTH  = 500;
+const RATE_LIMIT_MSGS = 20;
+const RATE_LIMIT_MS   = 30000;
+
+// ─── Message truncation ───────────────────────────────────────────────────────
+
+export function truncate(text) {
+  if (!text) return '';
+  const flat = text.replace(/\n+/g, ' ').trim();
+  return flat.length <= MAX_MSG_LENGTH ? flat : flat.slice(0, MAX_MSG_LENGTH - 3) + '...';
+}
+
+// ─── Validate OAuth token → get bot username ──────────────────────────────────
+
+async function getBotUsername(accessToken) {
+  return new Promise((resolve) => {
+    const options = {
+      hostname: 'id.twitch.tv',
+      path: '/oauth2/validate',
+      method: 'GET',
+      headers: { Authorization: `OAuth ${accessToken}` },
+    };
+    const req = https.request(options, (res) => {
+      let body = '';
+      res.on('data', d => { body += d; });
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(body);
+          resolve(json.login || null);
+        } catch {
+          resolve(null);
+        }
+      });
+    });
+    req.on('error', () => resolve(null));
+    req.end();
+  });
+}
+
+// ─── Bot class ────────────────────────────────────────────────────────────────
+
+class TwitchBot {
+  constructor({ channel, accessToken, allowedIds, botUsername }) {
+    this.channel     = channel.toLowerCase().replace(/^#/, '');
+    this.accessToken = accessToken;
+    this.allowedIds  = allowedIds; // Set of allowed Twitch user IDs
+    this.botUsername = botUsername;
+    this.ws          = null;
+    this._connected  = false;
+    this._reconnectDelay = 5000;
+
+    // Rate-limit queue: max 20 messages per 30 seconds
+    this._msgQueue   = [];
+    this._msgCount   = 0;
+    this._rateReset  = null;
+  }
+
+  /** Send a chat message, respecting rate limits */
+  say(message) {
+    const text = truncate(message);
+    if (!text) return;
+    this._msgQueue.push(text);
+    this._drainQueue();
+  }
+
+  _drainQueue() {
+    if (!this._connected || this._msgQueue.length === 0) return;
+
+    if (this._msgCount >= RATE_LIMIT_MSGS) {
+      // Queue is full — wait for rate limit window to reset
+      return;
+    }
+
+    const msg = this._msgQueue.shift();
+    if (!msg) return;
+
+    this._send(`PRIVMSG #${this.channel} :${msg}`);
+    this._msgCount++;
+
+    // Schedule rate limit reset
+    if (!this._rateReset) {
+      this._rateReset = setTimeout(() => {
+        this._msgCount = 0;
+        this._rateReset = null;
+        this._drainQueue(); // Process any queued messages
+      }, RATE_LIMIT_MS);
+    }
+
+    // Continue draining if under limit
+    if (this._msgCount < RATE_LIMIT_MSGS && this._msgQueue.length > 0) {
+      setImmediate(() => this._drainQueue());
+    }
+  }
+
+  _send(raw) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(raw);
+    }
+  }
+
+  /** Connect to Twitch IRC over WebSocket */
+  connect() {
+    this.ws = new WebSocket(IRC_URL);
+
+    this.ws.on('open', () => {
+      this._connected = false; // not yet authenticated
+      // Request tags capability for user-id in messages
+      this._send('CAP REQ :twitch.tv/tags');
+      this._send(`PASS oauth:${this.accessToken}`);
+      this._send(`NICK ${this.botUsername}`);
+    });
+
+    this.ws.on('message', (raw) => {
+      const line = raw.toString().trim();
+
+      // Handle PING / PONG
+      if (line.startsWith('PING')) {
+        this._send('PONG :tmi.twitch.tv');
+        return;
+      }
+
+      // Authentication result
+      if (line.includes('376') || line.includes('001')) {
+        // RPL_ENDOFMOTD or RPL_WELCOME — authenticated
+        this._send(`JOIN #${this.channel}`);
+      }
+
+      // Joined channel
+      if (line.includes(`JOIN #${this.channel}`)) {
+        this._connected = true;
+        this._reconnectDelay = 5000; // reset backoff on success
+        console.log(`\n  ${getConfig().name} Twitch Bot`);
+        console.log(`  @${this.botUsername} → #${this.channel}`);
+        if (this.allowedIds.size > 0) {
+          console.log(`  Allowed IDs: ${[...this.allowedIds].join(', ')}`);
+        } else {
+          console.log('  WARNING: No allowed IDs configured — all commands are blocked');
+        }
+        console.log('');
+
+        // Resume any interrupted pipeline
+        setTimeout(() => autoResumePipeline().catch(err => console.error('[Twitch] Resume error:', err.message)), 3000);
+      }
+
+      // Authentication failure
+      if (line.includes('NOTICE') && line.includes('Login authentication failed')) {
+        console.error('\n  [Twitch] Authentication failed — check TWITCH_ACCESS_TOKEN\n');
+        this.ws.close();
+        return;
+      }
+
+      // PRIVMSG — incoming chat message
+      if (line.includes('PRIVMSG')) {
+        this._handleMessage(line);
+      }
+    });
+
+    this.ws.on('error', (err) => {
+      console.error(`  [Twitch] WebSocket error: ${err.message}`);
+    });
+
+    this.ws.on('close', () => {
+      this._connected = false;
+      console.log(`  [Twitch] Disconnected. Reconnecting in ${this._reconnectDelay / 1000}s...`);
+      setTimeout(() => {
+        this._reconnectDelay = Math.min(this._reconnectDelay * 2, 60000); // exponential backoff, max 60s
+        this.connect();
+      }, this._reconnectDelay);
+    });
+  }
+
+  /** Parse a PRIVMSG line and dispatch to command or message handler */
+  _handleMessage(raw) {
+    // Parse IRCv3 tags + message
+    // Format: @key=val;key=val :user!user@user.tmi.twitch.tv PRIVMSG #channel :message
+    let tags = {};
+    let rest = raw;
+
+    if (raw.startsWith('@')) {
+      const spaceIdx = raw.indexOf(' ');
+      const tagStr = raw.slice(1, spaceIdx);
+      rest = raw.slice(spaceIdx + 1);
+      for (const part of tagStr.split(';')) {
+        const eqIdx = part.indexOf('=');
+        if (eqIdx !== -1) tags[part.slice(0, eqIdx)] = part.slice(eqIdx + 1);
+      }
+    }
+
+    const privmsgMatch = rest.match(/^:(\S+)!\S+ PRIVMSG #\S+ :(.+)$/);
+    if (!privmsgMatch) return;
+
+    const username = privmsgMatch[1];
+    const message  = privmsgMatch[2].trim();
+    const userId   = tags['user-id'] || '';
+
+    // Auth check — enforce TWITCH_ALLOWED_IDS allowlist (applies to both ! commands and NL)
+    if (this.allowedIds.size > 0 && !this.allowedIds.has(userId) && !this.allowedIds.has(username)) {
+      // Log the blocked attempt for audit, but do NOT respond in chat
+      console.log(`  [Twitch] BLOCKED: ${username} (user-id: ${userId || 'unknown'}) — not in TWITCH_ALLOWED_IDS`);
+      return;
+    }
+
+    if (message.startsWith('!')) {
+      // Explicit bot command — ! prefix
+      console.log(`  [Twitch] Command from ${username} (${userId}): ${message}`);
+      const [cmdRaw, ...argParts] = message.slice(1).split(' ');
+      const cmd  = cmdRaw.toLowerCase();
+      const args = argParts.join(' ').trim();
+      this._dispatch(cmd, args, username);
+    } else if (this._messageHandler) {
+      // Natural language — pass to NL handler if registered
+      console.log(`  [Twitch] Message from ${username} (${userId}): ${message.slice(0, 80)}`);
+      this._messageHandler(message, username);
+    }
+  }
+
+  _dispatch(cmd, args, username) {
+    if (this._commandHandler) {
+      this._commandHandler(cmd, args, username, this);
+    }
+  }
+
+  onCommand(handler) {
+    this._commandHandler = handler;
+  }
+
+  /** Register a handler for non-! natural language messages from authorized users */
+  onMessage(handler) {
+    this._messageHandler = handler;
+  }
+
+  disconnect() {
+    this._connected = false;
+    if (this.ws) {
+      this.ws.removeAllListeners('close'); // prevent auto-reconnect on intentional close
+      this.ws.close();
+    }
+    if (this._rateReset) {
+      clearTimeout(this._rateReset);
+      this._rateReset = null;
+    }
+  }
+}
+
+// ─── Start bot ────────────────────────────────────────────────────────────────
+
+export async function startBot() {
+  // Guard against double execution
+  const GUARD_KEY = '__aicc_twitch_bot_started__';
+  if (globalThis[GUARD_KEY]) return;
+  globalThis[GUARD_KEY] = true;
+
+  await loadConfig().catch(() => {});
+
+  const prefix = (() => { try { return getConfig().envPrefix; } catch { return 'AICC'; } })();
+
+  const CHANNEL      = env('TWITCH_CHANNEL');
+  const ACCESS_TOKEN = env('TWITCH_ACCESS_TOKEN');
+  const ALLOWED_RAW  = env('TWITCH_ALLOWED_IDS');
+
+  if (!CHANNEL) {
+    console.error(`\n  Missing ${prefix}_TWITCH_CHANNEL environment variable.\n`);
+    process.exit(1);
+  }
+
+  if (!ACCESS_TOKEN) {
+    console.error(`\n  Missing ${prefix}_TWITCH_ACCESS_TOKEN environment variable.`);
+    console.error('  Generate one at https://dev.twitch.tv/console with chat:read and chat:edit scopes.\n');
+    process.exit(1);
+  }
+
+  // Validate token and get bot username
+  const botUsername = await getBotUsername(ACCESS_TOKEN);
+  if (!botUsername) {
+    console.error('\n  Failed to validate TWITCH_ACCESS_TOKEN. Check the token is valid and not expired.\n');
+    process.exit(1);
+  }
+
+  // Build allowed user ID set
+  const allowedIds = new Set();
+  if (ALLOWED_RAW) {
+    ALLOWED_RAW.split(',').map(s => s.trim()).filter(Boolean).forEach(id => allowedIds.add(id));
+  }
+
+  const bot = new TwitchBot({ channel: CHANNEL, accessToken: ACCESS_TOKEN, allowedIds, botUsername });
+
+  // Register command handlers
+  registerCommands(bot);
+
+  // Set up pipeline notifications
+  setupNotifications(bot, bus);
+
+  // Start watching status.json
+  bus.startWatching();
+
+  // Connect to Twitch IRC
+  bot.connect();
+
+  // Cleanup on exit
+  process.on('SIGINT', () => {
+    bus.stopWatching();
+    bot.disconnect();
+    process.exit(0);
+  });
+}
+
+// Auto-start when run directly
+if (process.argv[1]?.endsWith('bot.js')) {
+  startBot();
+}

package/lib/twitch/commands.js

@@ -0,0 +1,302 @@
+/**
+ * Twitch bot command handlers — with intent engine parity to Telegram.
+ *
+ * Two layers of input handling:
+ *   1. Explicit ! commands:  !status, !feature, !bug, !review, !approve,
+ *                            !reject, !deploy, !logs, !health, !ai,
+ *                            !yes, !no, !intel, !help
+ *   2. Natural language:     Any non-! message from an authorized user is
+ *                            passed through the shared intent engine, which
+ *                            maps phrases like "deploy now" to the deploy intent.
+ *
+ * Confirmation flow (Twitch has no inline keyboards):
+ *   State-changing intents (approve/deploy/reject/fix/implement/fix_and_review)
+ *   are held in pendingActions[username] and require !yes to execute.
+ *   Read-only intents (review/status/logs/health) run immediately.
+ *
+ * Shared modules (same as Telegram):
+ *   - lib/shared/action-runner.js  — all pipeline actions
+ *   - lib/utils/intent-engine.js   — matchIntent, matchLearnedPhrase, learnPhrase
+ *   - lib/utils/format.js          — formatForPlatform
+ */
+import * as actions from '../shared/action-runner.js';
+import { formatForPlatform } from '../utils/format.js';
+import { getIntelStats, learnPhrase, matchIntent, matchLearnedPhrase } from '../utils/intent-engine.js';
+import { truncate } from './bot.js';
+
+// Strip markdown and truncate AI output for Twitch plain text
+function formatReply(text) {
+  const { text: formatted } = formatForPlatform(
+    typeof text === 'object' ? (text?.message || JSON.stringify(text)) : String(text || ''),
+    'twitch'
+  );
+  return truncate(formatted);
+}
+
+// ── Per-user pending confirmation state ────────────────────────────────────
+// Shape: { intent, desc, actionFn, rawText }
+const pendingActions = new Map();
+function setPending(username, data) { pendingActions.set(username, data); }
+function getPending(username)       { return pendingActions.get(username) || null; }
+function clearPending(username)     { pendingActions.delete(username); }
+
+// ── Unified action executor ────────────────────────────────────────────────
+// Awaits actionFn(), sends result to chat, and reinforces learning on success.
+async function runAction(bot, actionFn, { successMsg = null, errorMsg = 'Error', rawText = null, intent = null } = {}) {
+  try {
+    const res = await actionFn();
+    const msg = res?.message || res?.summary || successMsg || 'Done.';
+    bot.say(truncate(msg));
+    if (rawText && intent) learnPhrase(rawText, intent, { trigger: 'twitch_confirmed' });
+  } catch (err) {
+    bot.say(truncate(`${errorMsg}: ${err.message}`));
+  }
+}
+
+// ── Intent → action mapper (mirrors Telegram) ──────────────────────────────
+// Returns { requiresConfirm, desc, actionFn } or null for unknown intents.
+function buildIntentContext(intent, rawText, statusData) {
+  const cleanDesc = rawText
+    .replace(/\b(can you|please|could you|let'?s|we should|implement|fix|create|add|build|deploy|review|approve|reject)\b/gi, '')
+    .replace(/\s+/g, ' ').trim() || rawText;
+
+  switch (intent) {
+    case 'review':
+      return { requiresConfirm: false, desc: 'Run code review', actionFn: () => actions.runReview() };
+    case 'approve':
+      return { requiresConfirm: true, desc: `Approve current feature (stage: ${statusData?.stage || 'unknown'})`, actionFn: () => actions.runApprove() };
+    case 'deploy':
+      return { requiresConfirm: true, desc: `Deploy to target (stage: ${statusData?.stage || 'unknown'})`, actionFn: () => actions.runDeploy() };
+    case 'fix':
+      return { requiresConfirm: true, desc: `Fix bug: "${cleanDesc.slice(0, 80)}"`, actionFn: () => actions.runBugFix(cleanDesc) };
+    case 'implement':
+      return { requiresConfirm: true, desc: `New feature: "${cleanDesc.slice(0, 80)}"`, actionFn: () => actions.runNewFeature(cleanDesc) };
+    case 'fix_and_review':
+      return {
+        requiresConfirm: true,
+        desc: 'Fix bug then run code review',
+        actionFn: async () => { await actions.runBugFix(cleanDesc); return actions.runReview(); },
+      };
+    default:
+      return null;
+  }
+}
+
+// ── Natural language handler ───────────────────────────────────────────────
+// Called by bot.onMessage() for every non-! message from an authorized user.
+async function handleNaturalLanguage(bot, text, username) {
+  const statusData   = actions.getStatusData();
+  const learned      = matchLearnedPhrase(text);
+  const intentResult = learned || matchIntent(text, statusData);
+  if (!intentResult) return;
+
+  const { intent, confidence } = intentResult;
+  // Higher threshold for Twitch (noisier public chat)
+  if (confidence < 0.65) {
+    console.log(`  [Twitch] NL low confidence (${confidence.toFixed(2)}) for "${text.slice(0, 50)}" — skipped`);
+    return;
+  }
+  console.log(`  [Twitch] NL intent: ${intent} (${confidence.toFixed(2)}) from ${username}`);
+
+  const ctx = buildIntentContext(intent, text, statusData);
+  if (!ctx) return;
+
+  if (!ctx.requiresConfirm) {
+    bot.say(`→ ${ctx.desc}...`);
+    await runAction(bot, ctx.actionFn, { rawText: text, intent });
+  } else {
+    setPending(username, { intent, desc: ctx.desc, actionFn: ctx.actionFn, rawText: text });
+    bot.say(truncate(`${ctx.desc} — reply !yes to confirm or !no to cancel`));
+  }
+}
+
+// ── Command registry ───────────────────────────────────────────────────────
+export function registerCommands(bot) {
+
+  // Wire natural-language handler for non-! messages
+  bot.onMessage(async (text, username) => {
+    await handleNaturalLanguage(bot, text, username);
+  });
+
+  bot.onCommand(async (cmd, args, username) => {
+    switch (cmd) {
+
+      // ── !help ────────────────────────────────────────────────────────────
+      case 'help': {
+        bot.say(
+          '!status !feature <desc> !bug <desc> !review !approve !reject [reason] ' +
+          '!deploy !logs !health !ai <q> !intel — or just chat naturally!'
+        );
+        break;
+      }
+
+      // ── !status ──────────────────────────────────────────────────────────
+      case 'status': {
+        const s = actions.getStatusData();
+        if (!s) { bot.say('No pipeline status available.'); break; }
+        bot.say(truncate(`Stage: ${s.stage || 'idle'} | Feature: ${s.current_feature || 'none'} | Mode: ${s.pipeline_mode || 'manual'}`));
+        break;
+      }
+
+      // ── !feature <desc> ──────────────────────────────────────────────────
+      case 'feature': {
+        if (!args || !args.trim()) { bot.say('Usage: !feature <description>'); break; }
+        bot.say(`Starting feature: ${truncate(args)}...`);
+        await runAction(bot, () => actions.runNewFeature(args.trim(), 'manual', 'feature'), {
+          successMsg: 'Feature submitted!', errorMsg: 'Feature failed',
+          rawText: args.trim(), intent: 'implement',
+        });
+        break;
+      }
+
+      // ── !bug <desc> ──────────────────────────────────────────────────────
+      case 'bug': {
+        if (!args || !args.trim()) { bot.say('Usage: !bug <description>'); break; }
+        bot.say(`Fixing: ${truncate(args)}...`);
+        await runAction(bot, () => actions.runBugFix(args.trim()), {
+          successMsg: 'Bug fix started!', errorMsg: 'Bug fix failed',
+          rawText: args.trim(), intent: 'fix',
+        });
+        break;
+      }
+
+      // ── !review ──────────────────────────────────────────────────────────
+      case 'review': {
+        bot.say('Running code review...');
+        await runAction(bot, () => actions.runReview(), {
+          successMsg: 'Review complete.', errorMsg: 'Review failed',
+          rawText: '!review', intent: 'review',
+        });
+        break;
+      }
+
+      // ── !deploy ──────────────────────────────────────────────────────────
+      case 'deploy': {
+        bot.say('Deploying...');
+        await runAction(bot, () => actions.runDeploy(), {
+          successMsg: 'Deploy successful!', errorMsg: 'Deploy failed',
+          rawText: '!deploy', intent: 'deploy',
+        });
+        break;
+      }
+
+      // ── !approve ─────────────────────────────────────────────────────────
+      case 'approve': {
+        bot.say('Approving feature...');
+        await runAction(bot, () => actions.runApprove(), {
+          successMsg: 'Feature approved!', errorMsg: 'Approve failed',
+          rawText: '!approve', intent: 'approve',
+        });
+        break;
+      }
+
+      // ── !reject [reason] ─────────────────────────────────────────────────
+      case 'reject': {
+        const reason = args && args.trim() ? args.trim() : 'Rejected via Twitch';
+        bot.say(`Rejecting: ${truncate(reason)}...`);
+        await runAction(bot, () => actions.runReject(reason), {
+          successMsg: 'Feature rejected.', errorMsg: 'Reject failed',
+          rawText: reason, intent: 'reject',
+        });
+        break;
+      }
+
+      // ── !yes — confirm pending action ────────────────────────────────────
+      case 'yes': {
+        const pending = getPending(username);
+        if (!pending) { bot.say('Nothing pending. Trigger an action via chat or !commands first.'); break; }
+        clearPending(username);
+        bot.say(`Confirmed: ${truncate(pending.desc)}...`);
+        await runAction(bot, pending.actionFn, {
+          successMsg: 'Done!', errorMsg: 'Action failed',
+          rawText: pending.rawText, intent: pending.intent,
+        });
+        break;
+      }
+
+      // ── !no — cancel pending action ──────────────────────────────────────
+      case 'no': {
+        const pending = getPending(username);
+        if (!pending) { bot.say('Nothing pending to cancel.'); break; }
+        clearPending(username);
+        bot.say('Cancelled.');
+        break;
+      }
+
+      // ── !logs ────────────────────────────────────────────────────────────
+      case 'logs': {
+        const logData = actions.getLogsData(5);
+        if (!logData || logData.length === 0) { bot.say('No recent logs.'); break; }
+        const lines = Array.isArray(logData)
+          ? logData.slice(-3).join(' | ')
+          : String(logData).split('\n').filter(Boolean).slice(-3).join(' | ');
+        bot.say(truncate(`Logs: ${lines}`));
+        break;
+      }
+
+      // ── !health ──────────────────────────────────────────────────────────
+      case 'health': {
+        const data = await actions.getHealthData();
+        const ok = (v) => v ? '✓' : '✗';
+        bot.say(
+          `Health — gemini:${ok(data.gemini?.available)} ` +
+          `claude:${ok(data.claude?.available)} ` +
+          `copilot:${ok(data.copilot?.available)} ` +
+          `stage:${data.pipeline?.stage || 'idle'}`
+        );
+        break;
+      }
+
+      // ── !ai <question> ───────────────────────────────────────────────────
+      case 'ai': {
+        if (!args || !args.trim()) { bot.say('Usage: !ai <question>'); break; }
+        bot.say('Thinking...');
+        try {
+          const result = await actions.askAI(args.trim());
+          if (result?.confirm === true) {
+            const desc = result.desc || result.action || 'Proposed action';
+            setPending(username, { intent: result.action || 'implement', desc, actionFn: () => actions.runNewFeature(desc), rawText: args.trim() });
+            bot.say(truncate(`Ready: "${desc}" — reply !yes to confirm or !no to cancel`));
+            break;
+          }
+          if (result?.pipelineAction) {
+            const pa = result.pipelineAction;
+            const pipeMap = {
+              review:         () => actions.runReview(),
+              approve:        () => actions.runApprove(),
+              deploy:         () => actions.runDeploy(),
+              fix:            () => actions.runBugFix(result.desc || args.trim()),
+              implement:      () => actions.runNewFeature(result.desc || args.trim()),
+              fix_and_review: async () => { await actions.runBugFix(result.desc || args.trim()); return actions.runReview(); },
+            };
+            if (pipeMap[pa]) {
+              bot.say(`→ Executing: ${pa}...`);
+              await runAction(bot, pipeMap[pa], { successMsg: `${pa} complete.`, errorMsg: `${pa} failed`, rawText: args.trim(), intent: pa });
+            } else {
+              bot.say(formatReply(result));
+            }
+            break;
+          }
+          bot.say(formatReply(result));
+        } catch (err) {
+          bot.say(truncate(`AI error: ${err.message}`));
+        }
+        break;
+      }
+
+      // ── !intel — intent engine diagnostics ───────────────────────────────
+      case 'intel': {
+        try {
+          const stats = getIntelStats();
+          bot.say(truncate(`Intent engine — patterns: ${stats.patternCount ?? '?'} | learned: ${stats.learnedCount ?? '?'} | confidence: ${stats.avgConfidence ?? '?'}`));
+        } catch {
+          bot.say('Intent engine stats unavailable.');
+        }
+        break;
+      }
+
+      default:
+        break;
+    }
+  });
+}