ai-control-center 1.15.2

package/lib/telegram/commands.js

@@ -0,0 +1,1267 @@
+/**
+ * Telegram bot command handlers.
+ *
+ * Full parity with the terminal CLI main menu:
+ *   1. New Feature          /feature <desc>
+ *   2. Fix a Bug            /bug <desc>
+ *   3. Review Code          /review
+ *   4. Approve              /approve
+ *   5. Reject               /reject <reason>
+ *   6. Deploy               /deploy
+ *   7. Debug / Logs         /logs
+ *   8. Pipeline Status      /status
+ *   9. Clean Up             /cleanup
+ *   A. Toggle Auto-Pilot    /autopilot
+ *   R. Reset / Abandon      /reset
+ *      Health Check         /health
+ *      Main Menu            /menu
+ *      Ask AI               /ask <question>
+ */
+import { getConfig } from '../config.js';
+import * as actions from '../shared/action-runner.js';
+import { bus } from '../shared/event-bus.js';
+import { formatCostSummary, getCostSummary, getActiveBudget } from '../utils/cost-tracker.js';
+import { formatForPlatform } from '../utils/format.js';
+import { learnPhrase, matchIntent, matchLearnedPhrase } from '../utils/intent-engine.js';
+import {
+  confirmActionKeyboard,
+  deployKeyboard,
+  docPageKeyboard,
+  docsKeyboard,
+  featureModeKeyboard,
+  logPageKeyboard,
+  logsKeyboard,
+  mainMenuKeyboard,
+  reviewActionsKeyboard
+} from './keyboards.js';
+
+/** Emit a user action event so hub can push it to office canvas */
+function emitUserAction(action, extra = {}) {
+  bus.emitEvent('user_action', { action, ...extra });
+}
+
+// Helper: send AI markdown response formatted for Telegram HTML
+function replyAI(ctx, text) {
+  const { text: formatted, options } = formatForPlatform(text, 'telegram');
+  // Split at 4000 chars but don't break mid-HTML-tag
+  const chunks = formatted.match(/[\s\S]{1,4000}/g) || ['No response.'];
+  return Promise.all(chunks.map(chunk => ctx.reply(chunk, options)));
+}
+
+// Persistent pending feature storage — survives bot restarts.
+// Falls back to in-memory Map for projects where getWorkflowDir() isn't available yet.
+const _pendingFallback = new Map();
+
+function setPendingFeature(chatId, pending) {
+  _pendingFallback.set(chatId, pending); // always keep in-memory copy too
+  try { actions.savePendingChat(chatId, pending); } catch { /* non-fatal */ }
+}
+
+function getPendingFeature(chatId) {
+  // Disk-backed first, fallback to in-memory
+  try {
+    const disk = actions.loadPendingChat(chatId);
+    if (disk) return disk;
+  } catch { /* non-fatal */ }
+  return _pendingFallback.get(chatId) || null;
+}
+
+function deletePendingFeature(chatId) {
+  _pendingFallback.delete(chatId);
+  try { actions.clearPendingChat(chatId); } catch { /* non-fatal */ }
+}
+
+// Per-chat conversation history (in-memory, survives bot restarts via OpenClaw session)
+const chatHistories = new Map();
+const MAX_HISTORY_MESSAGES = 12; // last 6 exchanges
+
+function getHistory(chatId) {
+  return chatHistories.get(chatId) || [];
+}
+
+function addToHistory(chatId, role, content) {
+  const history = getHistory(chatId);
+  history.push({ role, content: content.slice(0, 600) });
+  if (history.length > MAX_HISTORY_MESSAGES) history.splice(0, history.length - MAX_HISTORY_MESSAGES);
+  chatHistories.set(chatId, history);
+}
+
+function buildHistoryContext(chatId) {
+  const history = getHistory(chatId);
+  if (!history.length) return '';
+  return 'Recent conversation (for context):\n' +
+    history.map(m => `[${m.role === 'user' ? 'User' : 'Assistant'}]: ${m.content}`).join('\n');
+}
+
+export function registerCommands(bot) {
+
+  // ── /start ──────────────────────────────────────────────────────────────────
+  bot.command('start', (ctx) => {
+    console.log(`  Chat ID: ${ctx.chat.id} (save this as ${getConfig().envPrefix}_TELEGRAM_CHAT_ID)`);
+    ctx.reply(
+      `*${getConfig().name} AI Pipeline*\n\n` +
+      `*Pipeline Actions:*\n` +
+      `/feature \\<desc\\> — New Feature\n` +
+      `/bug \\<desc\\> — Fix a Bug\n` +
+      `/review — Review Code \\(Reviewer\\)\n` +
+      `/approve — Approve current feature\n` +
+      `/reject \\<reason\\> — Reject / Request Fixes\n\n` +
+      `*Deploy & Monitor:*\n` +
+      `/deploy — Deploy to org\n` +
+      `/status — Pipeline status\n` +
+      `/logs — Recent session log entries\n` +
+      `/health — System health check\n\n` +
+      `*Management:*\n` +
+      `/autopilot — Toggle auto\\-pilot\n` +
+      `/cleanup — Clean up workspace\n` +
+      `/reset — Reset / Abandon feature\n` +
+      `*Local AI \\(Ollama\\):*\n` +
+      `/ask \\<question\\> — Ask local AI\n` +
+      `/aimode — Toggle AI mode \\(hybrid/cloud/local\\)\n\n` +
+      `*Observability:*\n` +
+      `/costs — AI usage \\& cost summary\n` +
+      `/audit — Recent audit log\n\n` +
+      `/menu — Show main menu buttons\n\n` +
+      `_Pipeline events are pushed automatically\\._`,
+      { parse_mode: 'MarkdownV2' }
+    );
+  });
+
+  // ── /menu — inline keyboard with all options ──────────────────────────────
+  bot.command('menu', (ctx) => {
+    ctx.reply('Main Menu — tap an action:', { reply_markup: mainMenuKeyboard() });
+  });
+
+  // ── /status ─────────────────────────────────────────────────────────────────
+  bot.command('status', async (ctx) => {
+    const s = actions.getStatusData();
+    const stage     = s.stage || 'idle';
+    const feature   = s.current_feature || 'none';
+    const mode      = s.pipeline_mode || 'manual';
+    const next      = s.next || '-';
+    const updated   = s.updated_at ? new Date(s.updated_at).toLocaleTimeString() : '-';
+
+    const stageEmoji = {
+      idle:                    '💤',
+      inbox:                   '📥',
+      spec_complete:           '📝',
+      arch_complete:           '🏗',
+      implementation_complete: '⚡',
+      implementation_failed:   '❌',
+      review_complete:         '🔍',
+      approved:                '✅',
+      rejected:                '❌',
+      deployed:                '🚀',
+    };
+
+    const icon = stageEmoji[stage] || '🔄';
+    const modeIcon = mode === 'auto' ? '⚡ auto' : '🖐 manual';
+
+    // Show banned models if any
+    const banned = s._bannedModels || [];
+    const bannedLine = banned.length > 0
+      ? `\n⚠️ <b>Rate-limited:</b> ${banned.map(b => `${b.model} (${b.type}, clears ~${b.clearsIn})`).join(', ')}\n`
+      : '';
+
+    // Predictive pipeline duration
+    let predictionLine = '';
+    try {
+      const { predictCompletion, formatPrediction } = await import('../utils/pipeline.js');
+      const { getCostEntries } = await import('../utils/cost-tracker.js');
+      if (stage && stage !== 'idle') {
+        const entries = getCostEntries();
+        const prediction = predictCompletion(stage, entries);
+        predictionLine = '\n' + formatPrediction(prediction);
+      }
+    } catch { /* prediction is optional */ }
+
+    ctx.reply(
+      `${icon} <b>Pipeline Status</b>\n\n` +
+      `Stage:   <code>${stage}</code>\n` +
+      `Feature: <code>${feature}</code>\n` +
+      `Mode:    ${modeIcon}\n` +
+      `Next:    ${next}\n` +
+      `Updated: ${updated}\n` +
+      bannedLine + predictionLine + `\n` +
+      `Use /docs to view pipeline documents\n` +
+      `Use /logs for recent activity`,
+      { parse_mode: 'HTML' }
+    );
+  });
+
+  // ── /leaderboard — AI model performance leaderboard ─────────────────────
+  bot.command('leaderboard', async (ctx) => {
+    try {
+      const { getLeaderboard, formatLeaderboard } = await import('../utils/agent-leaderboard.js');
+      const entries = getLeaderboard();
+      const text = formatLeaderboard(entries);
+      await ctx.reply(text, { parse_mode: undefined });
+    } catch (e) {
+      await ctx.reply(`❌ Leaderboard error: ${e.message}`);
+    }
+  });
+
+  // ── /docs — Browse pipeline documents ────────────────────────────────────
+  bot.command('docs', (ctx) => {
+    const docs = actions.listAvailableDocs();
+    if (docs.length === 0) {
+      ctx.reply('No pipeline documents yet. Start a feature first with /feature or /bug');
+      return;
+    }
+    ctx.reply('📂 <b>Pipeline Documents</b>\n\nChoose a document to view:', {
+      parse_mode: 'HTML',
+      reply_markup: docsKeyboard(docs),
+    });
+  });
+
+  // ── doc: callbacks — paginated document viewer ────────────────────────────
+  bot.callbackQuery('doc:list', async (ctx) => {
+    try { await ctx.answerCallbackQuery(); } catch { /* query expired */ }
+    const docs = actions.listAvailableDocs();
+    if (docs.length === 0) {
+      ctx.editMessageText('No pipeline documents yet.');
+      return;
+    }
+    ctx.editMessageText('📂 <b>Pipeline Documents</b>\n\nChoose a document to view:', {
+      parse_mode: 'HTML',
+      reply_markup: docsKeyboard(docs),
+    });
+  });
+
+  bot.callbackQuery(/^doc:view:(.+):(\d+)$/, async (ctx) => {
+    const key  = ctx.match[1];
+    const page = parseInt(ctx.match[2], 10);
+    try { await ctx.answerCallbackQuery(); } catch { /* query expired */ }
+
+    const doc = actions.readDocPaged(key, page);
+    if (!doc) {
+      ctx.editMessageText('Document not found.');
+      return;
+    }
+
+    const header = `📄 <b>${doc.name}</b>  (${doc.page + 1}/${doc.totalPages}, ${doc.totalChars} chars)\n\n`;
+    // Escape HTML special chars in the document content
+    const safe = doc.content
+      .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+
+    ctx.editMessageText(header + `<code>${safe}</code>`, {
+      parse_mode: 'HTML',
+      reply_markup: docPageKeyboard(key, doc.page, doc.totalPages),
+    });
+  });
+
+
+  bot.command('feature', (ctx) => {
+    const desc = ctx.message.text.replace(/^\/feature\s*/, '').trim();
+    if (!desc || desc.length < 10) {
+      ctx.reply('Usage: `/feature <description>`\n\nDescription must be at least 10 characters.\n\nExample: `/feature Add MYOB inbound sync for invoices`', { parse_mode: 'Markdown' });
+      return;
+    }
+    setPendingFeature(ctx.chat.id, { description: desc, type: 'feature' });
+    ctx.reply(`New Feature: "${desc}"\n\nSelect pipeline mode:`, { reply_markup: featureModeKeyboard('feature') });
+  });
+
+  // ── /bug <description> — Fix a Bug ────────────────────────────────────────
+  bot.command('bug', (ctx) => {
+    const desc = ctx.message.text.replace(/^\/bug\s*/, '').trim();
+    if (!desc || desc.length < 10) {
+      ctx.reply('Usage: `/bug <description>`\n\nDescription must be at least 10 characters.\n\nExample: `/bug Circuit breaker not resetting after cooldown`', { parse_mode: 'Markdown' });
+      return;
+    }
+    setPendingFeature(ctx.chat.id, { description: desc, type: 'bug' });
+    ctx.reply(`Bug Fix: "${desc}"\n\nSelect pipeline mode:`, { reply_markup: featureModeKeyboard('bug') });
+  });
+
+  // Handle feature/bug mode selection callback
+  bot.callbackQuery(/^fmode:(feature|bug):(manual|auto)$/, async (ctx) => {
+    const type = ctx.match[1];
+    const mode = ctx.match[2];
+    try { await ctx.answerCallbackQuery(); } catch { /* query expired */ }
+
+    const pending = getPendingFeature(ctx.chat.id);
+    if (!pending) {
+      ctx.reply('Session expired. Please submit the feature/bug again.');
+      return;
+    }
+    deletePendingFeature(ctx.chat.id);
+
+    ctx.reply(`Starting ${type === 'bug' ? 'bug fix' : 'feature'} pipeline (${mode} mode)... This may take several minutes.`);
+    emitUserAction('feature_submitted', { type, mode, username: ctx.from?.username, description: pending.description.slice(0, 80) });
+
+    const result = await actions.runNewFeature(pending.description, mode, pending.type);
+    if (result.success) {
+      ctx.reply(`Pipeline started!\n\nFeature: \`${result.featureId}\`\nMode: ${mode}\nStage: \`${result.status?.stage}\``, { parse_mode: 'Markdown' });
+    } else {
+      ctx.reply(`Failed to start: ${result.error}`);
+    }
+  });
+
+  // ── /review — trigger code review ──────────────────────────────────
+  bot.command('review', async (ctx) => {
+    const status = actions.getStatusData();
+    const hasFeature = !!status.current_feature;
+    const canReview = hasFeature && [
+      'inbox', 'spec_complete', 'arch_complete',
+      'implementation_complete', 'rejected', 'review_complete',
+    ].includes(status.stage);
+
+    if (!canReview) {
+      // Show latest review if one exists
+      const review = actions.getLatestReview();
+      if (review) {
+        const preview = review.content.slice(0, 500).replace(/[_*[\]()~`>#+=|{}.!-]/g, '\\$&');
+        ctx.reply(
+          `*Latest Review: ${review.verdict}*\n\nFile: \`${review.name}\`\n\n${preview}...`,
+          { parse_mode: 'Markdown' }
+        );
+      } else {
+        ctx.reply('No active feature to review. Start a feature first with `/feature <description>`', { parse_mode: 'Markdown' });
+      }
+      return;
+    }
+
+    ctx.reply('Starting code review... This may take a few minutes.');
+
+    // JS-native review — no shell script dependency
+    try {
+      const result = await actions.runReview();
+      if (!result.success) {
+        ctx.reply(`Review failed: ${result.error}`);
+        return;
+      }
+      const review = actions.getLatestReview();
+      if (!review) {
+        ctx.reply('Review finished but no review file found.');
+        return;
+      }
+
+      const verdict = review.verdict === 'APPROVED' ? 'APPROVED' : 'REJECTED';
+      const preview = review.content.slice(0, 800);
+      ctx.reply(`Review complete: *${verdict}*\n\n\`\`\`\n${preview}\n\`\`\``, { parse_mode: 'Markdown' });
+
+      if (review.verdict === 'APPROVED') {
+        ctx.reply('Feature approved by reviewer! What next?', { reply_markup: reviewActionsKeyboard() });
+        return;
+      }
+
+      // ── REJECTED → auto-fix then re-review (one cycle) ─────────────────────
+      ctx.reply('🔧 Coder is fixing the blockers from the review...');
+      const fixResult = await actions.runFix();
+      if (!fixResult.success) {
+        ctx.reply(
+          `❌ Auto-fix failed: ${fixResult.error}\n\nUse /reject <instructions> to send specific fixes to Coder, or /review to retry manually.`
+        );
+        return;
+      }
+
+      ctx.reply('✅ Fixes applied — running review again...');
+      const result2 = await actions.runReview();
+      if (!result2.success) {
+        ctx.reply(`Re-review failed: ${result2.error}`);
+        return;
+      }
+      const review2 = actions.getLatestReview();
+      if (!review2) {
+        ctx.reply('Re-review finished but no review file found.');
+        return;
+      }
+
+      const verdict2 = review2.verdict === 'APPROVED' ? 'APPROVED' : 'REJECTED';
+      const preview2 = review2.content.slice(0, 800);
+      ctx.reply(`Re-review complete: *${verdict2}*\n\n\`\`\`\n${preview2}\n\`\`\``, { parse_mode: 'Markdown' });
+
+      if (review2.verdict === 'APPROVED') {
+        ctx.reply('✅ Feature approved after fixes! What next?', { reply_markup: reviewActionsKeyboard() });
+      } else {
+        ctx.reply(
+          '⚠️ Still rejected after one fix cycle.\n\nOptions:\n' +
+          '• /reject <specific instructions> — give Coder targeted guidance\n' +
+          '• /review — run another fix+review cycle\n' +
+          '• /approve — force-approve and deploy anyway'
+        );
+      }
+    } catch (err) {
+      ctx.reply(`Review failed: ${err.message}`);
+    }
+  });
+
+  // ── /implement — Manually trigger or restart Coder implementation ────────
+  bot.command('implement', async (ctx) => {
+    emitUserAction('implement_start', { username: ctx.from?.username });
+    const s = actions.getStatusData();
+    const allowedStages = ['arch_complete', 'implementation_failed'];
+    if (!allowedStages.includes(s.stage)) {
+      ctx.reply(
+        `⚠️ Cannot start implementation from stage <code>${s.stage}</code>\n\n` +
+        `Implementation can only run from:\n` +
+        `• <code>arch_complete</code> — after architecture is done\n` +
+        `• <code>implementation_failed</code> — to retry a failed run\n\n` +
+        `Current stage: <code>${s.stage}</code> (next: <code>${s.next || '-'}</code>)`,
+        { parse_mode: 'HTML' }
+      );
+      return;
+    }
+    ctx.reply('⚡ Starting Coder implementation…');
+    const result = await actions.runImplementation();
+    if (!result.success) {
+      ctx.reply(`❌ Implementation failed: ${result.error}`);
+    }
+    // Success notifications come via the event bus / pipeline push-events
+  });
+
+  // ── /approve ────────────────────────────────────────────────────────────────
+  bot.command('approve', async (ctx) => {
+    emitUserAction('approve', { username: ctx.from?.username });
+    const result = await actions.runApprove();
+    if (result.success) {
+      ctx.reply('Feature approved! Ready to deploy.', { reply_markup: deployKeyboard() });
+    } else {
+      ctx.reply(`Cannot approve: ${result.error}`);
+    }
+  });
+
+  // ── /reject <reason> ───────────────────────────────────────────────────────
+  bot.command('reject', async (ctx) => {
+    const reason = ctx.message.text.replace(/^\/reject\s*/, '').trim();
+    if (!reason) {
+      ctx.reply('Usage: `/reject <reason>`\n\nExample: `/reject Missing error handling in main service`', { parse_mode: 'Markdown' });
+      return;
+    }
+    emitUserAction('reject', { reason, username: ctx.from?.username });
+    const result = await actions.runReject(reason);
+    if (result.success) {
+      ctx.reply(`Rejected. Reason: ${reason}\n\nFixes will be dispatched to Coder.`);
+    } else {
+      ctx.reply(`Cannot reject: ${result.error}`);
+    }
+  });
+
+  // ── /deploy ─────────────────────────────────────────────────────────────────
+  bot.command('deploy', (ctx) => {
+    emitUserAction('deploy_start', { username: ctx.from?.username });
+    ctx.reply('Deploy — select test level:', { reply_markup: deployKeyboard() });
+  });
+
+  bot.callbackQuery(/^deploy:(.+)$/, async (ctx) => {
+    const testLevel = ctx.match[1];
+    try { await ctx.answerCallbackQuery(); } catch { /* query expired */ }
+    emitUserAction('deploy_confirm', { testLevel, username: ctx.from?.username });
+    ctx.reply(`Deploying with ${testLevel}... (this may take a few minutes)`);
+
+    const result = await actions.runDeploy(testLevel);
+    if (result.success) {
+      ctx.reply('Deploy successful!');
+    } else {
+      const error = result.stderr?.slice(0, 300) || result.error || 'Unknown error';
+      ctx.reply(`Deploy failed:\n\`\`\`\n${error}\n\`\`\``, { parse_mode: 'Markdown' });
+    }
+  });
+
+  // ── /logs ───────────────────────────────────────────────────────────────────
+  bot.command('logs', (ctx) => {
+    const sessions = actions.listAvailableLogs();
+    if (sessions.length === 0) {
+      ctx.reply('No session logs available yet.');
+      return;
+    }
+    ctx.reply('🗒 <b>Session Logs</b>\n\nChoose a log to view:', { parse_mode: 'HTML', reply_markup: logsKeyboard(sessions) });
+  });
+
+  // ── /health ─────────────────────────────────────────────────────────────────
+  bot.command('health', async (ctx) => {
+    const data = await actions.getHealthData();
+    const ok = (v) => v ? '✓' : '✗';
+
+    let ollamaLine = `ollama:  ${ok(data.ollama?.available)}`;
+    if (data.ollama?.available) {
+      ollamaLine += ` (${data.ollama.model}, ${data.ollama.models?.length || 0} models)`;
+    }
+
+    ctx.reply(
+      `*System Health*\n\n` +
+      `*Cloud AI:*\n` +
+      `gemini:  ${ok(data.gemini?.available)}\n` +
+      `claude:  ${ok(data.claude?.available)}\n` +
+      `copilot: ${ok(data.copilot?.available)}\n\n` +
+      `*Local AI:*\n` +
+      `${ollamaLine}\n` +
+      `AI mode: ${data.ollama?.mode || 'hybrid'}\n\n` +
+      `*Tools:*\n` +
+      `sf:      ${ok(data.sf?.available)}\n` +
+      `gh:      ${ok(data.gh?.available)}\n\n` +
+      `*Workflow Dirs:*\n` +
+      `ai-workflow: ${ok(data.workflow?.aiWorkflow)}\n` +
+      `skills:      ${ok(data.workflow?.skills)}\n` +
+      `agents:      ${ok(data.workflow?.agents)}\n\n` +
+      `Stage: \`${data.pipeline?.stage || 'idle'}\``,
+      { parse_mode: 'Markdown' }
+    );
+  });
+
+  // ── /autopilot — Toggle auto-pilot ────────────────────────────────────────
+  bot.command('autopilot', (ctx) => {
+    const result = actions.toggleAutoPilot();
+    if (result.success) {
+      const icon = result.mode === 'auto' ? '⚡' : '⏸';
+      ctx.reply(`${icon} Auto-Pilot is now *${result.mode.toUpperCase()}*`, { parse_mode: 'Markdown' });
+    } else {
+      ctx.reply(`Cannot toggle: ${result.error}`);
+    }
+  });
+
+  // ── /cleanup — Clean up workspace ─────────────────────────────────────────
+  bot.command('cleanup', async (ctx) => {
+    ctx.reply('Cleaning up workspace...');
+    const result = await actions.runCleanup();
+    if (result.success) {
+      ctx.reply('Workspace cleaned up successfully.');
+    } else {
+      ctx.reply(`Cleanup failed: ${result.error}`);
+    }
+  });
+
+  // ── /reset — Reset / Abandon feature ──────────────────────────────────────
+  bot.command('reset', (ctx) => {
+    const result = actions.runReset();
+    if (result.success) {
+      ctx.reply(`Feature "${result.feature}" abandoned. Pipeline reset to idle.`);
+    } else {
+      ctx.reply(`Cannot reset: ${result.error}`);
+    }
+  });
+
+  // ── /retry — Retry current stage from checkpoint ──────────────────────────
+  bot.command('retry', async (ctx) => {
+    const arg = ctx.message.text.replace(/^\/retry\s*/, '').trim().toLowerCase();
+    const fresh = arg === 'fresh';
+    const result = await actions.retryFromCheckpoint(fresh);
+    if (result.success) {
+      ctx.reply(`🔄 ${result.message}`, { parse_mode: 'HTML' });
+    } else {
+      ctx.reply(`❌ Cannot retry: ${result.error}`);
+    }
+  });
+
+  // ── /cost — Show cost breakdown and budget info ───────────────────────────
+  bot.command('cost', (ctx) => {
+    const status = actions.getStatusData();
+    const featureId = status.current_feature;
+    const summary = getCostSummary(featureId);
+    const budget = featureId ? getActiveBudget(featureId) : null;
+
+    let msg = formatCostSummary(summary, 'html');
+
+    if (budget) {
+      msg += `\n\n📊 <b>Token Budget</b>\n`;
+      msg += `${budget.formatGauge()}\n`;
+      msg += `Tokens: ${budget.usedTokens.toLocaleString()} / ${budget.maxTokens.toLocaleString()}\n`;
+      if (budget.savedByCheckpoints > 0) {
+        msg += `Saved by checkpoints: ~${budget.savedByCheckpoints.toLocaleString()} tokens\n`;
+      }
+    }
+
+    ctx.reply(msg, { parse_mode: 'HTML' });
+  });
+
+  // ── /dryrun — Run pipeline dry run ────────────────────────────────────────
+  bot.command('dryrun', async (ctx) => {
+    const desc = ctx.message.text.replace(/^\/dryrun\s*/, '').trim() || 'Test feature (dry run)';
+    ctx.reply('🧪 Starting dry run...');
+    const result = await actions.runDryRun(desc);
+    if (result.success) {
+      ctx.reply(`✅ ${result.message}`, { parse_mode: 'HTML' });
+    } else {
+      ctx.reply(`❌ Dry run failed: ${result.error}`);
+    }
+  });
+
+  // ── /ask <question> — Ask local AI (Ollama) ────────────────────────────────
+  bot.command('ask', async (ctx) => {
+    const question = ctx.message.text.replace(/^\/ask\s*/, '').trim();
+    if (!question) {
+      ctx.reply('Usage: `/ask <question>`\n\nExample: `/ask How does the authentication flow work?`', { parse_mode: 'Markdown' });
+      return;
+    }
+
+    try {
+      await ctx.replyWithChatAction('typing');
+      const typingInterval = setInterval(() => ctx.replyWithChatAction('typing').catch(() => {}), 4000);
+      addToHistory(ctx.chat.id, 'user', question);
+      const result = await actions.askAI(question, buildHistoryContext(ctx.chat.id)).finally(() => clearInterval(typingInterval));
+      if (typeof result === 'string') {
+        addToHistory(ctx.chat.id, 'assistant', result);
+        await replyAI(ctx, result);
+      } else if (result?.error) {
+        await ctx.reply(`AI error: ${result.error}`);
+      } else {
+        await ctx.reply('No response from AI.');
+      }
+    } catch (err) {
+      console.error(`  [BOT] Reply failed: ${err.message}`);
+    }
+  });
+
+  // ── /aimode — Toggle AI mode (hybrid/cloud/local) ─────────────────────────
+  bot.command('aimode', async (ctx) => {
+    const status = await actions.getAIProviderStatus();
+    const ollamaOk = status.ollama.available ? '✓' : '✗';
+    const models = status.ollama.models?.slice(0, 5).join(', ') || 'none';
+
+    ctx.reply(
+      `*AI Mode: ${status.mode.toUpperCase()}*\n\n` +
+      `Ollama: ${ollamaOk} (model: \`${status.ollama.model}\`)\n` +
+      `Installed: ${models}\n\n` +
+      `Modes:\n` +
+      `• \`hybrid\` — Ollama for light tasks, cloud for heavy\n` +
+      `• \`cloud\` — Cloud AI only (skip Ollama)\n` +
+      `• \`local\` — Ollama only (no cloud)\n\n` +
+      `Set mode: \`${getConfig().envPrefix}_AI_MODE=hybrid\` env var\n` +
+      `Set model: \`OLLAMA_MODEL=llama3.1\` env var`,
+      { parse_mode: 'Markdown' }
+    );
+  });
+
+  // ── /costs — AI usage cost summary ──────────────────────────────────────────
+  bot.command('costs', (ctx) => {
+    const featureId = ctx.match?.trim() || undefined;
+    const data = actions.getCostsData(featureId);
+    if (!data || !data.summary) {
+      ctx.reply('No cost data recorded yet.');
+      return;
+    }
+    const s = data.summary;
+    const title = featureId ? `💰 Costs: <code>${featureId}</code>` : '💰 Overall AI Costs';
+    const lines = [
+      title,
+      '',
+      `Total calls: <b>${s.totalCalls}</b>`,
+      `Est. cost:   <b>$${s.totalCost?.toFixed(4) || '0.0000'}</b>`,
+      `Tokens (est): ${s.totalInputTokens || 0} in / ${s.totalOutputTokens || 0} out`,
+    ];
+    if (s.byProvider && Object.keys(s.byProvider).length) {
+      lines.push('', '<b>By provider:</b>');
+      for (const [prov, info] of Object.entries(s.byProvider)) {
+        lines.push(`  • ${prov}: ${info.calls} calls, $${info.cost?.toFixed(4) || '0'}`);
+      }
+    }
+    ctx.reply(lines.join('\n'), { parse_mode: 'HTML' });
+  });
+
+  // ── /audit — Recent audit log entries ──────────────────────────────────────
+  bot.command('audit', (ctx) => {
+    const arg = ctx.match?.trim() || '';
+    const filters = { limit: 15 };
+    if (arg) filters.event = arg.toUpperCase();
+    const data = actions.getAuditData(filters);
+    if (!data || !data.length) {
+      ctx.reply(arg ? `No audit entries for event: ${arg}` : 'No audit entries yet.');
+      return;
+    }
+    const lines = ['📋 <b>Audit Log</b> (last 15)', ''];
+    for (const e of data.slice(0, 15)) {
+      const ts = new Date(e.timestamp).toLocaleTimeString();
+      lines.push(`<code>${ts}</code> <b>${e.event}</b> ${e.featureId || ''}`);
+    }
+    if (arg) lines.push(`\nFilter: <code>${arg.toUpperCase()}</code>`);
+    lines.push('\nUsage: /audit [EVENT_TYPE]');
+    ctx.reply(lines.join('\n'), { parse_mode: 'HTML' });
+  });
+
+  // ── /assign — Assign project to AI IT department ─────────────────────────
+  bot.command('assign', async (ctx) => {
+    const text = (ctx.match || '').trim();
+    const parts = text.split(/\s+/);
+    const url   = parts[0];
+    const goal  = parts.slice(1).join(' ');
+    if (!url || !goal) {
+      ctx.reply('Usage: /assign &lt;url&gt; &lt;goal&gt;\nExample: /assign https://myapp.com Build e-commerce store', { parse_mode: 'HTML', link_preview_options: { is_disabled: true } });
+      return;
+    }
+    await ctx.reply(`Starting project assignment for ${url}...`, { link_preview_options: { is_disabled: true } });
+    try {
+      const { assignProjectAction } = await import('../actions/assign-project.js');
+      const result = await assignProjectAction({ url, goal });
+      if (!result.success) {
+        await ctx.reply('Assignment failed.');
+        return;
+      }
+      await ctx.reply(`Project assigned: ${result.projectId}\nStarting Browser QA audit...`, { link_preview_options: { is_disabled: true } });
+
+      // Auto-kick browser QA
+      const cfg = getConfig();
+      if (cfg.browserQA?.enabled) {
+        try {
+          const qaResult = await actions.runBrowserQA({ featureId: result.projectId, config: cfg });
+          if (qaResult.skipped) {
+            await ctx.reply('Browser QA skipped (not configured).');
+          } else if (qaResult.report?.summary) {
+            const s = qaResult.report.summary;
+            const icon = s.failed === 0 ? '✅' : '❌';
+            await ctx.reply(`${icon} QA: ${s.passed}/${s.totalRoutes} passed (${s.passRate}%)${s.failed > 0 ? ` — ${s.failed} issue(s) found` : ' — No issues!'}`);
+
+            if (qaResult.needsBugfix) {
+              const maxCycles = cfg.browserQA?.maxBugfixCycles || 3;
+              for (let cycle = 1; cycle <= maxCycles; cycle++) {
+                await ctx.reply(`🔧 Bug-fix cycle ${cycle}/${maxCycles}...`);
+                try {
+                  const { fixBugAction } = await import('../actions/fix-bug.js');
+                  await fixBugAction({ featureId: result.projectId, fromQA: true });
+                  const reQA = await actions.runBrowserQA({ featureId: result.projectId, config: cfg });
+                  if (!reQA.needsBugfix || reQA.failCount === 0) {
+                    await ctx.reply(`✅ Bugs fixed after ${cycle} cycle(s)!`);
+                    break;
+                  }
+                  if (cycle === maxCycles) {
+                    await ctx.reply(`⚠️ ${maxCycles} cycles exhausted. ${reQA.failCount} issue(s) remain. Escalating.`);
+                  }
+                } catch (fixErr) {
+                  await ctx.reply(`Fix error: ${fixErr.message.slice(0, 100)}`);
+                  break;
+                }
+              }
+            }
+          }
+        } catch (qaErr) {
+          await ctx.reply(`QA error: ${qaErr.message.slice(0, 150)}`);
+        }
+      } else {
+        await ctx.reply('Browser QA disabled. Enable in aicc.config.js to auto-test.');
+      }
+    } catch (err) {
+      await ctx.reply(`Assignment failed: ${err.message.slice(0, 150)}`);
+    }
+  });
+
+  // ── /suggest — Run suggestion agent ─────────────────────────────────────
+  bot.command('suggest', async (ctx) => {
+    await ctx.reply('Running suggestion analysis...');
+    try {
+      const { runSuggestionAgent } = await import('../agents/suggestion-agent.js');
+      const result = await runSuggestionAgent();
+      if (result.success && result.suggestions?.length > 0) {
+        const titles = result.suggestions.map((s, i) => `${i + 1}. ${s.title}`).join('\n');
+        await ctx.reply(`Feature suggestions:\n${titles}`);
+      } else if (result.skipped) {
+        await ctx.reply('Suggestion agent is disabled in config.');
+      } else {
+        await ctx.reply('No suggestions generated.');
+      }
+    } catch (err) {
+      await ctx.reply(`Suggestion failed: ${err.message.slice(0, 150)}`);
+    }
+  });
+
+  // ── /qa — Run browser QA test ───────────────────────────────────────────
+  bot.command('qa', async (ctx) => {
+    await ctx.reply('Starting browser QA...');
+    try {
+      const result = await actions.runBrowserQA();
+      if (result.skipped) {
+        await ctx.reply('Browser QA is disabled. Enable in aicc.config.js: browserQA.enabled = true');
+      } else if (result.report?.summary) {
+        const s = result.report.summary;
+        await ctx.reply(`QA complete: ${s.passed}/${s.totalRoutes} passed (${s.passRate}% pass rate). ${s.failed > 0 ? `${s.failed} issues found.` : 'No issues!'}`);
+      } else {
+        await ctx.reply(`QA result: ${result.error || 'unknown'}`);
+      }
+    } catch (err) {
+      await ctx.reply(`QA failed: ${err.message.slice(0, 150)}`);
+    }
+  });
+
+  // ── /threads — List open discussion threads ─────────────────────────────
+  bot.command('threads', async (ctx) => {
+    try {
+      const { getOpenThreads } = await import('../roleplay/discussion-threads.js');
+      const threads = getOpenThreads();
+      if (threads.length === 0) {
+        await ctx.reply('No open discussion threads.');
+        return;
+      }
+      const lines = threads.slice(0, 10).map(t =>
+        `• ${t.title} (${t.status}, ${t.messages.length} msg)`
+      );
+      await ctx.reply(`Open threads:\n${lines.join('\n')}`);
+    } catch (err) {
+      await ctx.reply(`Failed to list threads: ${err.message.slice(0, 100)}`);
+    }
+  });
+
+  // ── Inline keyboard callbacks from /menu ──────────────────────────────────
+  bot.callbackQuery(/^menu:(.+)$/, async (ctx) => {
+    const action = ctx.match[1];
+    try { await ctx.answerCallbackQuery(); } catch { /* query expired */ }
+
+    switch (action) {
+      case 'feature':
+        ctx.reply('Send a feature description:\n`/feature <description>`', { parse_mode: 'Markdown' });
+        break;
+      case 'bug':
+        ctx.reply('Send a bug description:\n`/bug <description>`', { parse_mode: 'Markdown' });
+        break;
+      case 'review': {
+        // Trigger review inline
+        const status = actions.getStatusData();
+        const canReview = status.current_feature && [
+          'inbox', 'spec_complete', 'arch_complete',
+          'implementation_complete', 'rejected', 'review_complete',
+        ].includes(status.stage);
+        if (!canReview) {
+          const review = actions.getLatestReview();
+          ctx.reply(review ? `Latest: *${review.verdict}* — \`${review.name}\`` : 'No review available.', { parse_mode: 'Markdown' });
+        } else {
+          ctx.reply('Starting review... use `/review` for full output.', { parse_mode: 'Markdown' });
+        }
+        break;
+      }
+      case 'status': {
+        const s = actions.getStatusData();
+        const stageEmoji = { idle:'💤', inbox:'📥', spec_complete:'📝', arch_complete:'🏗', implementation_complete:'⚡', review_complete:'🔍', approved:'✅', rejected:'❌', deployed:'🚀' };
+        const icon = stageEmoji[s.stage] || '🔄';
+        ctx.reply(`${icon} <code>${s.stage || 'idle'}</code>\n📦 <code>${s.current_feature || 'none'}</code>\n🔧 ${s.pipeline_mode || 'manual'} mode`, { parse_mode: 'HTML' });
+        break;
+      }
+      case 'docs': {
+        const docs = actions.listAvailableDocs();
+        if (docs.length === 0) {
+          ctx.reply('No pipeline documents yet.');
+        } else {
+          ctx.reply('📂 <b>Pipeline Documents</b>\n\nChoose a document to view:', { parse_mode: 'HTML', reply_markup: docsKeyboard(docs) });
+        }
+        break;
+      }
+      case 'approve': {
+        const r = await actions.runApprove();
+        ctx.reply(r.success ? 'Feature approved!' : `Cannot approve: ${r.error}`);
+        break;
+      }
+      case 'reject':
+        ctx.reply('Send rejection reason:\n`/reject <reason>`', { parse_mode: 'Markdown' });
+        break;
+      case 'deploy':
+        ctx.reply('Select test level:', { reply_markup: deployKeyboard() });
+        break;
+      case 'logs': {
+        const sessions = actions.listAvailableLogs();
+        if (sessions.length === 0) {
+          ctx.reply('No session logs available yet.');
+        } else {
+          ctx.reply('🗒 <b>Session Logs</b>\n\nChoose a log to view:', { parse_mode: 'HTML', reply_markup: logsKeyboard(sessions) });
+        }
+        break;
+      }
+      case 'autopilot': {
+        const r = actions.toggleAutoPilot();
+        ctx.reply(r.success ? `Auto-Pilot: *${r.mode.toUpperCase()}*` : r.error, { parse_mode: 'Markdown' });
+        break;
+      }
+      case 'cleanup': {
+        ctx.reply('Cleaning up...');
+        const r = await actions.runCleanup();
+        ctx.reply(r.success ? 'Done!' : `Failed: ${r.error}`);
+        break;
+      }
+      case 'health': {
+        const d = await actions.getHealthData();
+        const ok = (v) => v ? '✓' : '✗';
+        ctx.reply(`gemini: ${ok(d.gemini?.available)} | claude: ${ok(d.claude?.available)} | sf: ${ok(d.sf?.available)} | Stage: \`${d.pipeline?.stage || 'idle'}\``, { parse_mode: 'Markdown' });
+        break;
+      }
+      case 'reset': {
+        const r = actions.runReset();
+        ctx.reply(r.success ? `"${r.feature}" abandoned.` : r.error);
+        break;
+      }
+      case 'ask':
+        ctx.reply('Ask AI a question:\n`/ask <question>`', { parse_mode: 'Markdown' });
+        break;
+      case 'aimode': {
+        const ai = await actions.getAIProviderStatus();
+        ctx.reply(`AI Mode: *${ai.mode.toUpperCase()}* | Ollama: ${ai.ollama.available ? '✓' : '✗'} (\`${ai.ollama.model}\`)`, { parse_mode: 'Markdown' });
+        break;
+      }
+    }
+  });
+
+  // ── Action button callbacks (inline keyboard shortcuts) ────────────────────
+  bot.callbackQuery(/^action:(approve|reject|deploy|review|fix|docs|status)$/, async (ctx) => {
+    const action = ctx.match[1];
+    try { await ctx.answerCallbackQuery(`Running: ${action}...`); } catch { /* query expired */ }
+
+    if (action === 'approve') {
+      const r = await actions.runApprove();
+      ctx.reply(r.success ? '✅ Feature approved!' : `❌ Cannot approve: ${r.error}`);
+    } else if (action === 'reject') {
+      ctx.reply('Send rejection reason:\n<code>/reject &lt;reason&gt;</code>', { parse_mode: 'HTML' });
+    } else if (action === 'deploy') {
+      ctx.reply('🚀 Starting deployment...');
+      const r = await actions.runDeploy('RunLocalTests');
+      ctx.reply(r.success ? '✅ Deployment complete!' : `❌ Deploy failed: ${r.error?.slice(0, 200) || 'unknown'}`);
+    } else if (action === 'review') {
+      ctx.reply('🔍 Starting code review...');
+      const r = await actions.runReview();
+      ctx.reply(r.success ? '✅ Review complete — use /docs to read it.' : `❌ Review failed: ${r.error?.slice(0, 200) || 'unknown'}`);
+    } else if (action === 'fix') {
+      ctx.reply('🔧 Running auto-fix...');
+      const r = await actions.runFix();
+      ctx.reply(r.success ? '✅ Fix complete — run /review again to re-check.' : `❌ Fix failed: ${r.error?.slice(0, 200) || 'unknown'}`);
+    } else if (action === 'docs') {
+      const docs = actions.listAvailableDocs();
+      if (docs.length === 0) {
+        ctx.reply('No pipeline documents yet.');
+      } else {
+        const { InlineKeyboard } = await import('grammy');
+        const kb = new InlineKeyboard();
+        docs.slice(0, 8).forEach((d, i) => kb.text(d.label, `doc:view:${i}:0`).row());
+        ctx.reply('📂 <b>Pipeline Documents</b>\n\nChoose a document:', { parse_mode: 'HTML', reply_markup: kb });
+      }
+    } else if (action === 'status') {
+      const status = actions.getStatusData();
+      const stage = status.stage || 'unknown';
+      const feature = status.current_feature || '-';
+      const mode = status.mode === 'auto' ? '⚡ auto' : '🖐 manual';
+      ctx.reply(`📋 <b>Status</b>\n\nStage: <code>${stage}</code>\nFeature: <code>${feature}</code>\nMode: ${mode}`, { parse_mode: 'HTML' });
+    }
+  });
+
+  // ── Log list callback ─────────────────────────────────────────────────────
+  bot.callbackQuery('log:list', async (ctx) => {
+    try { await ctx.answerCallbackQuery(); } catch { /* query expired */ }
+    const sessions = actions.listAvailableLogs();
+    if (sessions.length === 0) {
+      ctx.reply('No session logs available yet.');
+    } else {
+      ctx.editMessageText('🗒 <b>Session Logs</b>\n\nChoose a log to view:', { parse_mode: 'HTML', reply_markup: logsKeyboard(sessions) });
+    }
+  });
+
+  // ── Log page view callback ────────────────────────────────────────────────
+  bot.callbackQuery(/^log:view:(\d+):(\d+)$/, async (ctx) => {
+    try { await ctx.answerCallbackQuery(); } catch { /* query expired */ }
+    const [, idx, pageStr] = ctx.match;
+    const page = parseInt(pageStr, 10) || 0;
+    const result = actions.readLogPaged(idx, page);
+    if (!result) {
+      ctx.reply('Log not found.');
+      return;
+    }
+    const header = `🗒 <b>${result.name}</b> — Page ${result.page + 1}/${result.totalPages} (${result.totalLines} lines)\n\n`;
+    const body = `<pre>${result.content.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')}</pre>`;
+    const text = header + body;
+    ctx.editMessageText(text, { parse_mode: 'HTML', reply_markup: logPageKeyboard(idx, result.page, result.totalPages) });
+  });
+
+  // ── Opus model confirmation callbacks ────────────────────────────────────
+  bot.callbackQuery(/^opus:(confirm|decline):(.+)$/, async (ctx) => {
+    const [, choice, featureId] = ctx.match;
+    try { await ctx.answerCallbackQuery(); } catch { /* query expired */ }
+    const confirmed = choice === 'confirm';
+    actions.resolveOpusConfirmation(featureId, confirmed);
+    if (confirmed) {
+      ctx.editMessageText(
+        `✅ Using <b>Claude Opus 4.6</b> for architecture (premium).\n\nPipeline continuing...`,
+        { parse_mode: 'HTML' }
+      );
+    } else {
+      ctx.editMessageText(
+        `⚡ Architect is working on the design.\n\nPipeline continuing...`,
+        { parse_mode: 'HTML' }
+      );
+    }
+  });
+
+  // ── Review loop confirmation callbacks ───────────────────────────────────
+  bot.callbackQuery(/^loop:(continue|stop):(.+)$/, async (ctx) => {
+    const [, choice, featureId] = ctx.match;
+    try { await ctx.answerCallbackQuery(); } catch { /* query expired */ }
+    const continueLoop = choice === 'continue';
+    actions.resolveLoopConfirmation(featureId, continueLoop);
+    if (continueLoop) {
+      ctx.editMessageText(
+        `🔁 Continuing auto-pilot — Coder will fix and re-review...`,
+        { parse_mode: 'HTML' }
+      );
+    } else {
+      ctx.editMessageText(
+        `🛑 Auto-pilot stopped. Use /reject to send specific fixes to Coder when ready.`,
+        { parse_mode: 'HTML' }
+      );
+    }
+  });
+
+  // ── Feature/Bug confirmation button callbacks ────────────────────────────
+  bot.callbackQuery(/^confirm:(.+)$/, async (ctx) => {
+    const data = ctx.match[1];
+    try { await ctx.answerCallbackQuery(); } catch { /* query expired */ }
+
+    // confirm:no — user is just chatting
+    if (data === 'no') {
+      ctx.editMessageText('💬 Got it — just chatting! Ask me anything.');
+      return;
+    }
+
+    // confirm:{type}:yes:{encodedDesc} or confirm:{type}:edit:{encodedDesc}
+    const parts = data.split(':');
+    if (parts.length < 3) return;
+    const [type, choice, ...descParts] = parts;
+    const desc = decodeURIComponent(descParts.join(':'));
+
+    if (choice === 'yes') {
+      // Proceed to pipeline mode selection (same as /feature or /bug flow)
+      setPendingFeature(ctx.chat.id, { description: desc, type });
+      const label = type === 'bug' ? '🐛 Bug Fix' : '✨ Feature';
+      ctx.editMessageText(`${label}: "${desc}"\n\nSelect pipeline mode:`, {
+        parse_mode: 'HTML',
+        reply_markup: featureModeKeyboard(type),
+      });
+      emitUserAction('confirm_feature', { type, description: desc, username: ctx.from?.username });
+      // Learn this interaction
+      learnPhrase(desc, type === 'bug' ? 'fix' : 'implement', { type });
+    } else if (choice === 'edit') {
+      ctx.editMessageText(`✏️ Sure! Send me a refined description for your ${type === 'bug' ? 'bug fix' : 'feature'}:`);
+    }
+  });
+
+  // ── Pipeline action confirmation button callbacks ────────────────────────
+  bot.callbackQuery(/^pipeconfirm:(.+)$/, async (ctx) => {
+    const data = ctx.match[1];
+    try { await ctx.answerCallbackQuery(); } catch { /* query expired */ }
+
+    // pipeconfirm:no — user is just chatting
+    if (data === 'no') {
+      ctx.editMessageText('💬 Got it — just chatting!');
+      return;
+    }
+
+    // pipeconfirm:{action}:yes
+    const parts = data.split(':');
+    if (parts.length < 2) return;
+    const action = parts[0];
+
+    const pipeActions = {
+      run_fix:            async () => { ctx.editMessageText('🔧 Running Coder fix...'); const r = await actions.runFix(); await ctx.reply(r.success ? '✅ Coder is on it.' : `❌ Fix failed: ${r.error}`); },
+      run_review:         async () => { ctx.editMessageText('🔍 Starting code review...'); const r = await actions.runReview(); if (!r.success) await ctx.reply(`❌ Review failed: ${r.error}`); },
+      run_fix_and_review: async () => {
+        ctx.editMessageText('🔧 Running Coder fix...');
+        const fr = await actions.runFix();
+        if (!fr.success) { await ctx.reply(`❌ Fix failed: ${fr.error}`); return; }
+        await ctx.reply('✅ Fixes applied — running review...');
+        const rr = await actions.runReview();
+        if (!rr.success) await ctx.reply(`❌ Review failed: ${rr.error}`);
+      },
+      run_approve:        async () => { ctx.editMessageText('✅ Approving...'); const r = await actions.runApprove(); await ctx.reply(r.success ? '✅ Feature approved!' : `❌ ${r.error}`); },
+      run_deploy:         async () => { ctx.editMessageText('🚀 Deploying...'); const r = await actions.runDeploy('RunLocalTests'); await ctx.reply(r.success ? '✅ Deployed!' : `❌ ${r.error?.slice(0,200)}`); },
+      run_implement:      async () => { const st = actions.getStatusData(); ctx.editMessageText(`⚡ Triggering Coder for ${st.current_feature}…`); const r = await actions.runImplementation(); if (!r.success) await ctx.reply(`❌ ${r.error}`); },
+    };
+
+    if (pipeActions[action]) {
+      emitUserAction(action, { username: ctx.from?.username, trigger: 'confirmed_button' });
+      await pipeActions[action]();
+      // Learn this interaction
+      learnPhrase(action, action.replace('run_', ''), {});
+    }
+  });
+
+  // ── Fallback: plain text → treat as /ask (natural conversation) ────────────
+  bot.on('message:text', async (ctx) => {
+    const text = (ctx.message.text || '').trim();
+    if (!text || text.startsWith('/')) return;
+
+    // ── Roleplay: dispatch CEO message to the room and stop (PM handles it) ──────
+    try {
+      const { isRoleplayEnabled } = await import('../roleplay/roleplay-config.js');
+      if (isRoleplayEnabled()) {
+        const { dispatchCEOMessage } = await import('../roleplay/room.js');
+        dispatchCEOMessage(text, ctx);
+        return; // PM owns the response — don't also trigger the AI pipeline
+      }
+    } catch { /* roleplay optional — non-fatal */ }
+
+    // ── Natural language → pipeline action dispatcher (dynamic intent engine) ──
+    // Uses learnable patterns instead of hardcoded regex.  Learned phrases are
+    // checked first (fastest, from past interactions), then dynamic patterns.
+    const s = actions.getStatusData();
+    const learned = matchLearnedPhrase(text);
+    const intent  = learned || matchIntent(text, s);
+
+    if (intent) {
+      const trigger = learned ? 'learned_phrase' : 'natural_language';
+      const intentActions = {
+        fix_and_review: async () => {
+          await ctx.reply('🔧 Running Coder fix...');
+          emitUserAction('fix_start', { username: ctx.from?.username, trigger });
+          const fr = await actions.runFix();
+          if (!fr.success) { await ctx.reply(`❌ Fix failed: ${fr.error}`); return; }
+          await ctx.reply('✅ Fixes applied — running review...');
+          emitUserAction('review_start', { username: ctx.from?.username, trigger });
+          const rr = await actions.runReview();
+          if (!rr.success) await ctx.reply(`❌ Review failed: ${rr.error}`);
+        },
+        fix: async () => {
+          await ctx.reply('🔧 Dispatching fixes to Coder...');
+          emitUserAction('fix_start', { username: ctx.from?.username, trigger });
+          const r = await actions.runFix();
+          await ctx.reply(r.success ? '✅ Coder is on it.' : `❌ Fix failed: ${r.error}`);
+        },
+        review: async () => {
+          await ctx.reply('🔍 Starting code review...');
+          emitUserAction('review_start', { username: ctx.from?.username, trigger });
+          const r = await actions.runReview();
+          if (!r.success) await ctx.reply(`❌ Review failed: ${r.error}`);
+        },
+        approve: async () => {
+          await ctx.reply('✅ Approving feature...');
+          emitUserAction('approve', { username: ctx.from?.username, trigger });
+          const r = await actions.runApprove();
+          await ctx.reply(r.success ? '✅ Feature approved!' : `❌ Cannot approve: ${r.error}`);
+        },
+        deploy: async () => {
+          await ctx.reply('🚀 Starting deployment...');
+          emitUserAction('deploy_start', { username: ctx.from?.username, trigger });
+          const r = await actions.runDeploy('RunLocalTests');
+          await ctx.reply(r.success ? '✅ Deployment complete!' : `❌ Deploy failed: ${r.error?.slice(0, 200) || 'unknown'}`);
+        },
+        implement: async () => {
+          await ctx.reply(`⚡ Triggering Coder implementation for <code>${s.current_feature}</code>…`, { parse_mode: 'HTML' });
+          emitUserAction('implement_start', { username: ctx.from?.username, trigger });
+          const r = await actions.runImplementation();
+          if (!r.success) await ctx.reply(`❌ Implementation failed: ${r.error}`);
+        },
+        rewrite_docs: async () => {
+          await ctx.reply('🔄 Rewriting spec and architecture docs...');
+          emitUserAction('rewrite_docs_start', { username: ctx.from?.username, trigger });
+          const r = await actions.runRewriteDocs(text);
+          if (!r.success) await ctx.reply(`❌ Rewrite failed: ${r.error}`);
+        },
+        reset: async () => {
+          emitUserAction('reset', { username: ctx.from?.username, trigger });
+          const r = actions.runReset();
+          if (r.success) {
+            await ctx.reply(`🔄 Pipeline reset to idle. Feature "${r.feature}" abandoned.`);
+          } else {
+            // No active feature — just force idle
+            try { actions.runCleanup(); } catch {}
+            await ctx.reply('💤 Pipeline is now idle.');
+          }
+        },
+        status: async () => {
+          const st = actions.getStatusData();
+          const stageEmoji = { idle:'💤', inbox:'📥', spec_complete:'📝', arch_complete:'🏗', implementation_complete:'⚡', review_complete:'🔍', approved:'✅', rejected:'❌', deployed:'🚀' };
+          const icon = stageEmoji[st.stage] || '🔄';
+          await ctx.reply(`${icon} Stage: <code>${st.stage || 'idle'}</code>\nFeature: <code>${st.current_feature || 'none'}</code>\nMode: ${st.pipeline_mode || 'manual'}`, { parse_mode: 'HTML' });
+        },
+        cleanup: async () => {
+          await ctx.reply('🧹 Cleaning up workspace...');
+          emitUserAction('cleanup', { username: ctx.from?.username, trigger });
+          const r = await actions.runCleanup();
+          await ctx.reply(r.success ? '✅ Workspace cleaned up.' : `❌ Cleanup failed: ${r.error}`);
+        },
+      };
+
+      const handler = intentActions[intent.intent];
+      if (handler) {
+        await handler();
+        learnPhrase(text, intent.intent, { trigger });
+        return;
+      }
+    }
+
+    try {
+      // Show typing indicator — refresh every 4s while AI is thinking
+      await ctx.replyWithChatAction('typing');
+      const typingInterval = setInterval(() => ctx.replyWithChatAction('typing').catch(() => {}), 4000);
+      addToHistory(ctx.chat.id, 'user', text);
+      const result = await actions.askAI(text, buildHistoryContext(ctx.chat.id)).finally(() => clearInterval(typingInterval));
+      if (typeof result === 'string') {
+        addToHistory(ctx.chat.id, 'assistant', result);
+        // Strip markdown code fences then find _action JSON (AI may wrap JSON in ```json...```)
+        const stripped = result.replace(/```(?:json)?\s*/gi, '').replace(/```/g, '');
+        // Use greedy match to handle descriptions containing special chars
+        const actionMatch = stripped.match(/\{"_action"\s*:\s*"[^"]+".+?\}(?=\s|$)/s);
+        // Debug: log what AI returned so we can diagnose action parsing failures
+        console.error(`  [BOT] AI response (${stripped.length} chars): ${stripped.slice(0, 300).replace(/\n/g, '\\n')}${stripped.length > 300 ? '...' : ''}`);
+        if (!actionMatch) {
+          const hasAction = stripped.includes('_action');
+          if (hasAction) {
+            console.error(`  [BOT] _action found in response but regex failed to parse. Response (last 500): ${stripped.slice(-500)}`);
+          }
+        }
+        if (actionMatch) {
+          let action;
+          try {
+            action = JSON.parse(actionMatch[0]);
+          } catch {
+            // Try to extract valid JSON by finding balanced braces
+            const start = stripped.indexOf('{"_action"');
+            if (start >= 0) {
+              let depth = 0;
+              let end = start;
+              for (let i = start; i < stripped.length; i++) {
+                if (stripped[i] === '{') depth++;
+                else if (stripped[i] === '}') { depth--; if (depth === 0) { end = i + 1; break; } }
+              }
+              try { action = JSON.parse(stripped.slice(start, end)); } catch { /* give up */ }
+            }
+          }
+          if (!action) {
+            console.error(`  [BOT] Failed to parse _action JSON: ${actionMatch[0].slice(0, 300)}`);
+          }
+          if (action) {
+            const explanation = stripped.slice(0, actionMatch.index).trim();
+
+            // ── Pipeline execution actions (AI decided to run something) ──────
+            const pipelineActions = {
+              run_fix:            async () => { await ctx.reply('🔧 Running Coder fix...'); const r = await actions.runFix(); await ctx.reply(r.success ? '✅ Coder is on it.' : `❌ Fix failed: ${r.error}`); },
+              run_review:         async () => { if (explanation) await replyAI(ctx, explanation); await ctx.reply('🔍 Starting code review...'); const r = await actions.runReview(); if (!r.success) await ctx.reply(`❌ Review failed: ${r.error}`); },
+              run_fix_and_review: async () => { await ctx.reply('🔧 Running Coder fix...'); const fr = await actions.runFix(); if (!fr.success) { await ctx.reply(`❌ Fix failed: ${fr.error}`); return; } await ctx.reply('✅ Fixes applied — running review...'); const rr = await actions.runReview(); if (!rr.success) await ctx.reply(`❌ Review failed: ${rr.error}`); },
+              run_approve:        async () => { await ctx.reply('✅ Approving...'); const r = await actions.runApprove(); await ctx.reply(r.success ? '✅ Feature approved!' : `❌ ${r.error}`); },
+              run_deploy:         async () => { await ctx.reply('🚀 Deploying...'); const r = await actions.runDeploy('RunLocalTests'); await ctx.reply(r.success ? '✅ Deployed!' : `❌ ${r.error?.slice(0,200)}`); },
+              run_implement:      async () => { const st = actions.getStatusData(); await ctx.reply(`⚡ Triggering Coder for <code>${st.current_feature}</code>…`, { parse_mode: 'HTML' }); const r = await actions.runImplementation(); if (!r.success) await ctx.reply(`❌ ${r.error}`); },
+              coder_fix:          async () => { await ctx.reply('🔧 Running Coder fix...'); const r = await actions.runFix(); await ctx.reply(r.success ? '✅ Coder is on it.' : `❌ Fix failed: ${r.error}`); },
+              run_rewrite_docs:   async () => { await ctx.reply('🔄 Rewriting spec and architecture docs...'); const r = await actions.runRewriteDocs(action.description || ''); if (!r.success) await ctx.reply(`❌ Rewrite failed: ${r.error}`); },
+              run_reset:          async () => { const r = actions.runReset(); if (r.success) { await ctx.reply(`🔄 Pipeline reset to idle. Feature "${r.feature}" abandoned.`); } else { try { await actions.runCleanup(); } catch {} await ctx.reply('💤 Pipeline is now idle.'); } },
+              run_cleanup:        async () => { await ctx.reply('🧹 Cleaning up...'); const r = await actions.runCleanup(); await ctx.reply(r.success ? '✅ Workspace cleaned up.' : `❌ Cleanup failed: ${r.error}`); },
+            };
+            if (pipelineActions[action._action]) {
+              if (explanation) await replyAI(ctx, explanation);
+              emitUserAction(action._action, { username: ctx.from?.username, trigger: 'ai_decision' });
+              await pipelineActions[action._action]();
+              return;
+            }
+
+            // ── Feature/bug creation (with optional inline confirmation) ─────
+            if (action._action === 'create_feature') {
+              const desc = (action.description || text).trim();
+              const type = action.type === 'bug' ? 'bug' : 'feature';
+              const label = type === 'bug' ? '🐛 Bug Fix' : '✨ Feature';
+
+              if (action.confirm) {
+                // Show inline confirmation buttons — saves an extra AI request
+                if (explanation) await replyAI(ctx, explanation);
+                await ctx.reply(`${label}: "${desc}"\n\nWant me to set this up?`, { reply_markup: confirmActionKeyboard(type, desc) });
+              } else {
+                // Legacy path: skip confirmation, go straight to pipeline mode
+                setPendingFeature(ctx.chat.id, { description: desc, type });
+                if (explanation) await replyAI(ctx, explanation);
+                await ctx.reply(`${label}: "${desc}"\n\nSelect pipeline mode:`, { reply_markup: featureModeKeyboard(type) });
+              }
+              return;
+            }
+          }
+        }
+        // Strip any _action JSON blobs the AI embedded before showing to user
+        const cleanResult = result
+          .replace(/\{"_action"\s*:[^}]+\}/g, '')
+          .replace(/\n{3,}/g, '\n\n')
+          .trim();
+        if (cleanResult) await replyAI(ctx, cleanResult);
+      } else if (result?.error) {
+        await ctx.reply(`AI error: ${result.error}`);
+      } else {
+        await ctx.reply('No response from AI.');
+      }
+    } catch (err) {
+      console.error(`  [BOT] Reply failed: ${err.message}`);
+    }
+  });
+}