clementine-agent 1.0.0

package/dist/channels/discord.js

@@ -0,0 +1,1832 @@
+/**
+ * Clementine TypeScript — Discord channel adapter.
+ *
+ * DM-only personal assistant bot using discord.js v14.
+ * Features: streaming responses, message chunking, model switching,
+ * heartbeat/cron commands, slash commands, and autonomous notifications.
+ */
+import { ActivityType, Client, EmbedBuilder, Events, GatewayIntentBits, Partials, REST, Routes, SlashCommandBuilder, } from 'discord.js';
+import pino from 'pino';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { chunkText, sendChunked, DiscordStreamingMessage, friendlyToolName, formatCronEmbed, } from './discord-utils.js';
+import { DISCORD_TOKEN, DISCORD_OWNER_ID, DISCORD_WATCHED_CHANNELS, MODELS, ASSISTANT_NAME, PKG_DIR, VAULT_DIR, BASE_DIR, DEFAULT_MODEL_TIER, ENABLE_1M_CONTEXT, } from '../config.js';
+import { findProjectByName, getLinkedProjects } from '../agent/assistant.js';
+import * as cronParser from 'cron-parser';
+const logger = pino({ name: 'clementine.discord' });
+const BOT_MESSAGE_TRACKING_LIMIT = 100;
+// ── Slash command definitions ──────────────────────────────────────────
+const slashCommands = [
+    new SlashCommandBuilder().setName('plan').setDescription('Break a task into parallel steps')
+        .addStringOption(o => o.setName('task').setDescription('What to plan').setRequired(true)),
+    new SlashCommandBuilder().setName('deep').setDescription('Extended mode (100 turns) for heavy tasks')
+        .addStringOption(o => o.setName('message').setDescription('Your message').setRequired(true)),
+    new SlashCommandBuilder().setName('quick').setDescription('Quick reply using Haiku model')
+        .addStringOption(o => o.setName('message').setDescription('Your message').setRequired(true)),
+    new SlashCommandBuilder().setName('opus').setDescription('Deep reply using Opus model')
+        .addStringOption(o => o.setName('message').setDescription('Your message').setRequired(true)),
+    new SlashCommandBuilder().setName('model').setDescription('Switch default model')
+        .addStringOption(o => o.setName('tier').setDescription('Model tier').setRequired(true)
+        .addChoices({ name: 'Haiku', value: 'haiku' }, { name: 'Sonnet', value: 'sonnet' }, { name: 'Opus', value: 'opus' })),
+    new SlashCommandBuilder().setName('cron').setDescription('Manage scheduled tasks')
+        .addStringOption(o => o.setName('action').setDescription('Action').setRequired(true)
+        .addChoices({ name: 'List jobs', value: 'list' }, { name: 'Run a job', value: 'run' }, { name: 'Enable a job', value: 'enable' }, { name: 'Disable a job', value: 'disable' }))
+        .addStringOption(o => o.setName('job').setDescription('Job name (for run/enable/disable)').setAutocomplete(true)),
+    new SlashCommandBuilder().setName('heartbeat').setDescription('Run heartbeat check manually'),
+    new SlashCommandBuilder().setName('tools').setDescription('List available MCP tools'),
+    new SlashCommandBuilder().setName('project').setDescription('Set active project context')
+        .addStringOption(o => o.setName('action').setDescription('Action').setRequired(true)
+        .addChoices({ name: 'List projects', value: 'list' }, { name: 'Set active project', value: 'set' }, { name: 'Clear active project', value: 'clear' }, { name: 'Show current', value: 'status' }))
+        .addStringOption(o => o.setName('name').setDescription('Project name (for set)').setAutocomplete(true)),
+    new SlashCommandBuilder().setName('workflow').setDescription('Manage multi-step workflows')
+        .addStringOption(o => o.setName('action').setDescription('Action').setRequired(true)
+        .addChoices({ name: 'List workflows', value: 'list' }, { name: 'Run a workflow', value: 'run' }))
+        .addStringOption(o => o.setName('name').setDescription('Workflow name (for run)').setAutocomplete(true))
+        .addStringOption(o => o.setName('inputs').setDescription('Input overrides (key=val key=val)')),
+    new SlashCommandBuilder().setName('status').setDescription('Check unleashed task progress')
+        .addStringOption(o => o.setName('job').setDescription('Job name (omit for all)')),
+    new SlashCommandBuilder().setName('self-improve').setDescription('Manage Clementine self-improvement')
+        .addSubcommand(sub => sub.setName('run').setDescription('Trigger self-improvement cycle'))
+        .addSubcommand(sub => sub.setName('status').setDescription('Show self-improvement status'))
+        .addSubcommand(sub => sub.setName('history').setDescription('Show experiment history'))
+        .addSubcommand(sub => sub.setName('pending').setDescription('List pending proposals')),
+    new SlashCommandBuilder().setName('team').setDescription('Manage agent team')
+        .addStringOption(o => o.setName('action').setDescription('Action').setRequired(true)
+        .addChoices({ name: 'List agents', value: 'list' }, { name: 'Agent status', value: 'status' }, { name: 'Recent messages', value: 'messages' }, { name: 'Topology', value: 'topology' })),
+    new SlashCommandBuilder().setName('dashboard').setDescription('Live system status embed (auto-refreshes)'),
+    new SlashCommandBuilder().setName('verbose').setDescription('Set response verbosity level')
+        .addStringOption(o => o.setName('level').setDescription('Verbosity level').setRequired(true)
+        .addChoices({ name: 'Quiet', value: 'quiet' }, { name: 'Normal', value: 'normal' }, { name: 'Detailed', value: 'detailed' })),
+    new SlashCommandBuilder().setName('clear').setDescription('Reset conversation session'),
+    new SlashCommandBuilder().setName('help').setDescription('Show all available commands'),
+];
+const botMessageMap = new Map();
+function trackBotMessage(messageId, context) {
+    botMessageMap.set(messageId, context);
+    // Evict oldest entries to prevent memory leak
+    if (botMessageMap.size > BOT_MESSAGE_TRACKING_LIMIT) {
+        const firstKey = botMessageMap.keys().next().value;
+        if (firstKey)
+            botMessageMap.delete(firstKey);
+    }
+}
+// ── Lazy memory store for feedback logging ──────────────────────────────
+let _feedbackStore = null;
+async function getFeedbackStore() {
+    if (_feedbackStore)
+        return _feedbackStore;
+    try {
+        const { MemoryStore } = await import('../memory/store.js');
+        const { MEMORY_DB_PATH } = await import('../config.js');
+        const store = new MemoryStore(MEMORY_DB_PATH, VAULT_DIR);
+        store.initialize();
+        _feedbackStore = store;
+        return _feedbackStore;
+    }
+    catch {
+        return null;
+    }
+}
+// ── Emoji to feedback rating mapping ────────────────────────────────────
+function emojiToRating(emoji) {
+    const positiveEmoji = ['\u{1F44D}', 'thumbsup', '\u{2764}\ufe0f', 'heart', '\u{2B50}', 'star'];
+    const negativeEmoji = ['\u{1F44E}', 'thumbsdown'];
+    if (positiveEmoji.includes(emoji))
+        return 'positive';
+    if (negativeEmoji.includes(emoji))
+        return 'negative';
+    return null;
+}
+// ── Approval buttons helper ──────────────────────────────────────────
+/**
+ * Send a message with approve/deny buttons and return the message.
+ * The requestId is embedded in the button customId for routing.
+ */
+async function sendApprovalButtons(channel, content, prefix, requestId, options) {
+    if (!('send' in channel))
+        return null;
+    const buttons = [
+        {
+            type: 2, // Button
+            style: 3, // Green
+            label: 'Approve',
+            custom_id: `${prefix}_${requestId}_approve`,
+        },
+    ];
+    if (options?.showRevise) {
+        buttons.push({
+            type: 2,
+            style: 1, // Blurple/Primary
+            label: 'Revise',
+            custom_id: `${prefix}_${requestId}_revise`,
+        });
+    }
+    buttons.push({
+        type: 2, // Button
+        style: 4, // Red
+        label: 'Cancel',
+        custom_id: `${prefix}_${requestId}_deny`,
+    });
+    const components = [{ type: 1, components: buttons }];
+    return channel.send({ content: content.slice(0, 2000), components: components });
+}
+// ── Tools listing ─────────────────────────────────────────────────────
+function formatToolsList() {
+    const lines = ['**Available Tools**\n'];
+    // MCP tools (parse from source)
+    const mcpSrc = path.join(PKG_DIR, 'src', 'tools', 'mcp-server.ts');
+    if (existsSync(mcpSrc)) {
+        const src = readFileSync(mcpSrc, 'utf-8');
+        const toolPattern = /server\.tool\(\s*'([^']+)',\s*(['"])(.+?)\2/gs;
+        const tools = [];
+        let match;
+        while ((match = toolPattern.exec(src)) !== null) {
+            tools.push({ name: match[1], desc: match[3] });
+        }
+        if (tools.length > 0) {
+            lines.push(`**MCP Tools** (${tools.length})`);
+            for (const t of tools) {
+                lines.push(`\`${t.name}\` — ${t.desc.slice(0, 80)}${t.desc.length > 80 ? '...' : ''}`);
+            }
+            lines.push('');
+        }
+    }
+    // SDK tools
+    lines.push('**SDK Built-in Tools** (8)');
+    lines.push('`Read` `Write` `Edit` `Bash` `Glob` `Grep` `WebSearch` `WebFetch`');
+    lines.push('');
+    // Claude Code plugins
+    const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+    if (existsSync(settingsPath)) {
+        try {
+            const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+            const plugins = Object.entries(settings.enabledPlugins ?? {})
+                .filter(([, v]) => v)
+                .map(([id]) => id.split('@')[0]);
+            if (plugins.length > 0) {
+                lines.push(`**Claude Code Plugins** (${plugins.length})`);
+                lines.push(plugins.map((p) => `\`${p}\``).join(' '));
+                lines.push('');
+            }
+        }
+        catch { /* ignore */ }
+    }
+    return lines.join('\n');
+}
+// ── Unleashed status helper ───────────────────────────────────────────
+function handleUnleashedStatus(jobName) {
+    const unleashedDir = path.join(BASE_DIR, 'unleashed');
+    if (!existsSync(unleashedDir)) {
+        return 'No unleashed tasks found.';
+    }
+    const dirs = readdirSync(unleashedDir).filter(d => {
+        try {
+            return statSync(path.join(unleashedDir, d)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
+    if (dirs.length === 0)
+        return 'No unleashed tasks found.';
+    // If a specific job is requested, show detailed status
+    if (jobName) {
+        const safeName = jobName.replace(/[^a-zA-Z0-9_-]/g, '_');
+        const statusFile = path.join(unleashedDir, safeName, 'status.json');
+        if (!existsSync(statusFile)) {
+            return `No status found for unleashed task "${jobName}".`;
+        }
+        try {
+            const status = JSON.parse(readFileSync(statusFile, 'utf-8'));
+            const elapsed = status.startedAt
+                ? Math.round((Date.now() - new Date(status.startedAt).getTime()) / 60000)
+                : 0;
+            const elapsedStr = elapsed < 60 ? `${elapsed}m` : `${Math.floor(elapsed / 60)}h ${elapsed % 60}m`;
+            const remaining = status.maxHours && status.startedAt
+                ? Math.max(0, Math.round(status.maxHours * 60 - elapsed))
+                : null;
+            const remainStr = remaining != null ? (remaining < 60 ? `${remaining}m` : `${Math.floor(remaining / 60)}h ${remaining % 60}m`) : 'unknown';
+            const lines = [
+                `**Unleashed: ${status.jobName ?? jobName}**`,
+                `Status: **${status.status ?? 'unknown'}**`,
+                `Phase: ${status.phase ?? 0}`,
+                `Elapsed: ${elapsedStr}`,
+                ...(status.status === 'running' ? [`Remaining: ~${remainStr}`] : []),
+                ...(status.lastPhaseOutputPreview ? [`Last output: _${status.lastPhaseOutputPreview.slice(0, 200)}_`] : []),
+            ];
+            return lines.join('\n');
+        }
+        catch {
+            return `Failed to read status for "${jobName}".`;
+        }
+    }
+    // List all unleashed tasks
+    const lines = ['**Unleashed Tasks:**\n'];
+    for (const dir of dirs) {
+        const statusFile = path.join(unleashedDir, dir, 'status.json');
+        if (!existsSync(statusFile))
+            continue;
+        try {
+            const status = JSON.parse(readFileSync(statusFile, 'utf-8'));
+            const elapsed = status.startedAt
+                ? Math.round((Date.now() - new Date(status.startedAt).getTime()) / 60000)
+                : 0;
+            const elapsedStr = elapsed < 60 ? `${elapsed}m` : `${Math.floor(elapsed / 60)}h ${elapsed % 60}m`;
+            const statusEmoji = status.status === 'running' ? '\u{1F535}' : status.status === 'completed' ? '\u2705' : '\u26A0\uFE0F';
+            lines.push(`${statusEmoji} **${status.jobName ?? dir}** — ${status.status ?? 'unknown'} · phase ${status.phase ?? 0} · ${elapsedStr}`);
+        }
+        catch { /* skip corrupt */ }
+    }
+    return lines.length === 1 ? 'No unleashed tasks found.' : lines.join('\n');
+}
+// ── Shared command helpers ────────────────────────────────────────────
+function handleHelp() {
+    return [
+        '**Commands** \u2014 also available as /slash commands',
+        '`!plan <task>` \u2014 Break a task into parallel steps',
+        '`!deep <msg>` \u2014 Extended mode (100 turns)',
+        '`!q <msg>` \u2014 Quick reply (Haiku) \u00b7 `!d <msg>` \u2014 Deep reply (Opus)',
+        '`!model [haiku|sonnet|opus]` \u2014 Switch default model',
+        '`!verbose [quiet|normal|detailed]` \u2014 Set response verbosity',
+        '`!project <name>` \u2014 Set active project \u00b7 `!project list|clear|status`',
+        '`!cron list|run|enable|disable` \u2014 Manage scheduled tasks',
+        '`!workflow list|run <name>` \u2014 Manage multi-step workflows',
+        '`!self-improve run|status|history|pending|apply|deny` \u2014 Self-improvement',
+        '`!team setup|list|status|messages|topology` \u2014 Manage agent team',
+        '`!status [job]` \u2014 Check unleashed task progress',
+        '`!dashboard` \u2014 Send a fresh system status embed',
+        '`!heartbeat` \u2014 Run heartbeat \u00b7 `!tools` \u2014 List tools \u00b7 `!clear` \u2014 Reset',
+        '`!stop` \u2014 Interrupt current response',
+        '`!help` \u2014 This message',
+    ].join('\n');
+}
+function handleModelSwitch(gateway, sessionKey, tier) {
+    const t = tier?.toLowerCase();
+    if (t && t in MODELS) {
+        gateway.setSessionModel(sessionKey, MODELS[t]);
+        return `Model switched to **${t}** (\`${MODELS[t]}\`).`;
+    }
+    const current = gateway.getSessionModel(sessionKey) ?? 'default';
+    return `Current model: \`${current}\`\nOptions: \`!model haiku\`, \`!model sonnet\`, \`!model opus\``;
+}
+function handleProjectCommand(gateway, sessionKey, action, projectName) {
+    if (action === 'list' || !action) {
+        const projects = getLinkedProjects();
+        if (projects.length === 0)
+            return 'No linked projects. Link projects from the dashboard.';
+        const current = gateway.getSessionProject(sessionKey);
+        const lines = projects.map(p => {
+            const name = path.basename(p.path);
+            const desc = p.description ? ` — ${p.description}` : '';
+            const active = current && p.path === current.path ? ' **(active)**' : '';
+            return `\`${name}\`${desc}${active}`;
+        });
+        return `**Linked Projects**\n${lines.join('\n')}`;
+    }
+    if (action === 'clear') {
+        gateway.clearSessionProject(sessionKey);
+        return 'Project context cleared. Auto-matching is back on.';
+    }
+    if (action === 'status') {
+        const current = gateway.getSessionProject(sessionKey);
+        if (!current)
+            return 'No active project. Using auto-matching.';
+        const name = path.basename(current.path);
+        const desc = current.description ? ` — ${current.description}` : '';
+        return `Active project: **${name}**${desc}\n\`${current.path}\``;
+    }
+    // action === 'set'
+    if (!projectName) {
+        const projects = getLinkedProjects();
+        if (projects.length === 0)
+            return 'No linked projects. Link projects from the dashboard.';
+        const names = projects.map(p => `\`${path.basename(p.path)}\``).join(', ');
+        return `Usage: \`!project <name>\`\nAvailable: ${names}`;
+    }
+    const project = findProjectByName(projectName);
+    if (!project) {
+        const projects = getLinkedProjects();
+        const names = projects.map(p => `\`${path.basename(p.path)}\``).join(', ');
+        return `Project "${projectName}" not found.\nAvailable: ${names}`;
+    }
+    // Clear the session so it starts fresh with the project's cwd/tools, then set the project
+    gateway.clearSession(sessionKey);
+    gateway.setSessionProject(sessionKey, project);
+    const name = path.basename(project.path);
+    const desc = project.description ? ` — ${project.description}` : '';
+    return `Switched to **${name}**${desc}\nWorking in \`${project.path}\`. Session cleared for fresh context.`;
+}
+function handleCronCommand(cronScheduler, action, jobName) {
+    // Returns a string for immediate replies, or null when async handling is needed (run)
+    if (action === 'list' || !action) {
+        return cronScheduler.listJobs();
+    }
+    if (action === 'disable' && jobName) {
+        return cronScheduler.disableJob(jobName);
+    }
+    if (action === 'enable' && jobName) {
+        return cronScheduler.enableJob(jobName);
+    }
+    if (!jobName) {
+        return 'Usage: `!cron list|run|disable|enable <job>`';
+    }
+    return null; // caller handles 'run' async
+}
+// ── Entry point ───────────────────────────────────────────────────────
+export async function startDiscord(gateway, heartbeat, cronScheduler, dispatcher, botManager) {
+    const watchedChannels = new Set(DISCORD_WATCHED_CHANNELS);
+    // Exclude channels owned by agent bots (they have their own Client)
+    if (botManager) {
+        for (const id of botManager.getOwnedChannelIds()) {
+            watchedChannels.delete(id);
+        }
+    }
+    const client = new Client({
+        intents: [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.DirectMessages,
+            GatewayIntentBits.MessageContent,
+            GatewayIntentBits.GuildMessageReactions,
+            GatewayIntentBits.DirectMessageReactions,
+            GatewayIntentBits.GuildMessages,
+        ],
+        partials: [Partials.Channel, Partials.Reaction, Partials.Message],
+    });
+    // ── Presence updater ─────────────────────────────────────────────
+    function updatePresence(sessionKey) {
+        if (!client.user)
+            return;
+        const info = gateway.getPresenceInfo(sessionKey ?? `discord:user:${DISCORD_OWNER_ID}`);
+        const parts = [
+            info.model,
+            info.project ?? 'No project',
+            `${info.exchanges}/${info.maxExchanges}`,
+            `${info.memoryCount}m`,
+        ];
+        client.user.setPresence({
+            activities: [{ name: parts.join(' · '), type: ActivityType.Watching }],
+            status: 'online',
+        });
+    }
+    // ── Live status embed (event-driven) ────────────────────────────
+    let statusEmbedMessage = null;
+    let statusEmbedDebounce = null;
+    function buildStatusEmbed() {
+        const now = new Date();
+        // ── Determine overall health color ─────────────────────────────
+        const todayStats = cronScheduler.getTodayStats();
+        const runningJobs = cronScheduler.getRunningJobs();
+        const runningWorkflows = cronScheduler.getRunningWorkflowNames();
+        const activeCount = runningJobs.length + runningWorkflows.length;
+        const healthColor = todayStats.errors > 0 ? 0xE74C3C // red — errors today
+            : activeCount > 0 ? 0xF39C12 // amber — work in progress
+                : 0x2ECC71; // green — all clear
+        const embed = new EmbedBuilder()
+            .setTitle(`${ASSISTANT_NAME} System Status`)
+            .setColor(healthColor)
+            .setTimestamp(now)
+            .setFooter({ text: 'Auto-updates on state changes \u00b7 !dashboard to refresh' });
+        // ── Lanes (only show if something is active or queued) ────────
+        const lanes = gateway.getLaneStatus();
+        const busyLanes = Object.entries(lanes).filter(([, l]) => l.active > 0 || l.queued > 0);
+        if (busyLanes.length > 0) {
+            const laneLines = busyLanes.map(([name, l]) => {
+                const queued = l.queued > 0 ? ` (+${l.queued} queued)` : '';
+                return `${name} **${l.active}**/${l.limit}${queued}`;
+            });
+            embed.addFields({ name: '\u{1F6A6} Lanes', value: laneLines.join(' \u00b7 '), inline: false });
+        }
+        // ── Active work ───────────────────────────────────────────────
+        const runningItems = [];
+        for (const j of runningJobs)
+            runningItems.push(`\u23F3 ${j}`);
+        for (const w of runningWorkflows)
+            runningItems.push(`\u{1F504} ${w} (workflow)`);
+        // Unleashed tasks
+        const unleashedDir = path.join(BASE_DIR, 'unleashed');
+        if (existsSync(unleashedDir)) {
+            try {
+                const dirs = readdirSync(unleashedDir).filter(d => {
+                    try {
+                        return statSync(path.join(unleashedDir, d)).isDirectory();
+                    }
+                    catch {
+                        return false;
+                    }
+                });
+                for (const dir of dirs) {
+                    const sf = path.join(unleashedDir, dir, 'status.json');
+                    if (!existsSync(sf))
+                        continue;
+                    try {
+                        const s = JSON.parse(readFileSync(sf, 'utf-8'));
+                        if (s.status !== 'running')
+                            continue;
+                        const elapsed = s.startedAt
+                            ? Math.round((Date.now() - new Date(s.startedAt).getTime()) / 60000)
+                            : 0;
+                        runningItems.push(`\u{1F680} ${s.jobName ?? dir} \u00b7 phase ${s.phase ?? 0} \u00b7 ${formatDuration(elapsed)}`);
+                    }
+                    catch { /* skip */ }
+                }
+            }
+            catch { /* skip */ }
+        }
+        if (runningItems.length > 0) {
+            embed.addFields({
+                name: `\u2699\uFE0F Active (${runningItems.length})`,
+                value: runningItems.join('\n'),
+                inline: false,
+            });
+        }
+        // ── Today's stats ─────────────────────────────────────────────
+        const statsLine = `\u2705 ${todayStats.ok} passed` +
+            (todayStats.errors > 0 ? ` \u00b7 \u274C ${todayStats.errors} failed` : '') +
+            (todayStats.skipped > 0 ? ` \u00b7 \u23ED ${todayStats.skipped} skipped` : '');
+        embed.addFields({ name: `\u{1F4CA} Today (${todayStats.total} runs)`, value: statsLine, inline: true });
+        // ── Sessions ──────────────────────────────────────────────────
+        const provenance = gateway.getAllProvenance();
+        embed.addFields({
+            name: '\u{1F4AC} Sessions',
+            value: `${provenance.size} active`,
+            inline: true,
+        });
+        // ── Next scheduled runs ───────────────────────────────────────
+        const jobDefs = cronScheduler.getJobDefinitions();
+        const upcoming = [];
+        for (const job of jobDefs) {
+            if (!job.active)
+                continue;
+            try {
+                const next = getNextCronRun(job.schedule);
+                if (next)
+                    upcoming.push({ name: job.name, nextMs: next.getTime(), agent: job.agentSlug });
+            }
+            catch { /* skip unparseable */ }
+        }
+        upcoming.sort((a, b) => a.nextMs - b.nextMs);
+        if (upcoming.length > 0) {
+            const nextLines = upcoming.slice(0, 6).map(u => {
+                const diffMs = u.nextMs - now.getTime();
+                const diffMin = Math.round(diffMs / 60000);
+                const timeStr = formatDuration(diffMin);
+                // Strip agent slug prefix from job name if it matches (avoid "ross-the-sdr:task ross-the-sdr")
+                const displayName = u.agent && u.name.startsWith(`${u.agent}:`)
+                    ? u.name.slice(u.agent.length + 1)
+                    : u.name;
+                const agentTag = u.agent ? ` _${u.agent}_` : '';
+                return `\`${timeStr.padStart(4)}\` ${displayName}${agentTag}`;
+            });
+            if (upcoming.length > 6)
+                nextLines.push(`_+${upcoming.length - 6} more_`);
+            embed.addFields({ name: '\u{1F4C5} Next Runs', value: nextLines.join('\n'), inline: false });
+        }
+        // ── Agents ────────────────────────────────────────────────────
+        const agents = gateway.getAgentManager().listAll();
+        if (agents.length > 0) {
+            const agentJobCounts = new Map();
+            for (const job of jobDefs) {
+                if (job.agentSlug && job.active) {
+                    agentJobCounts.set(job.agentSlug, (agentJobCounts.get(job.agentSlug) ?? 0) + 1);
+                }
+            }
+            const agentLines = agents.map(a => {
+                const jobCount = agentJobCounts.get(a.slug) ?? 0;
+                const model = a.model || 'sonnet';
+                const jobTag = jobCount > 0 ? `${jobCount} job${jobCount > 1 ? 's' : ''}` : 'no jobs';
+                return `**${a.name}** \u2014 ${model} \u00b7 ${jobTag}`;
+            });
+            embed.addFields({ name: `\u{1F916} Agents (${agents.length})`, value: agentLines.join('\n'), inline: false });
+        }
+        // ── Self-improvement ──────────────────────────────────────────
+        const siState = cronScheduler.getSelfImproveStatus();
+        const siPending = cronScheduler.getSelfImprovePending();
+        const m = siState.baselineMetrics;
+        const siLines = [];
+        if (m.feedbackPositiveRatio > 0 || m.cronSuccessRate > 0) {
+            siLines.push(`Feedback: ${(m.feedbackPositiveRatio * 100).toFixed(0)}% \u00b7 Cron: ${(m.cronSuccessRate * 100).toFixed(0)}% \u00b7 ${siState.totalExperiments} experiments`);
+        }
+        else {
+            siLines.push(`${siState.totalExperiments} experiments`);
+        }
+        if (siPending.length > 0) {
+            siLines.push(`**${siPending.length} pending approval${siPending.length > 1 ? 's' : ''}** \u2014 \`!self-improve pending\``);
+        }
+        embed.addFields({ name: `\u{1F52C} Self-Improvement (${siState.status})`, value: siLines.join('\n'), inline: false });
+        // ── Scheduled jobs summary ────────────────────────────────────
+        const enabledCount = jobDefs.filter(j => j.active).length;
+        const disabledCount = jobDefs.length - enabledCount;
+        const schedSummary = `${enabledCount} active` + (disabledCount > 0 ? ` \u00b7 ${disabledCount} disabled` : '');
+        embed.addFields({ name: '\u{1F4CB} Scheduled', value: schedSummary, inline: true });
+        // ── System info ──────────────────────────────────────────────
+        const modelLabel = DEFAULT_MODEL_TIER.charAt(0).toUpperCase() + DEFAULT_MODEL_TIER.slice(1);
+        const contextTag = ENABLE_1M_CONTEXT ? ' \u00b7 1M context' : '';
+        embed.addFields({ name: '\u{2699}\u{FE0F} System', value: `${modelLabel}${contextTag}`, inline: true });
+        return embed;
+    }
+    /** Format a duration in minutes to a compact human string. */
+    function formatDuration(minutes) {
+        if (minutes < 1)
+            return '<1m';
+        if (minutes < 60)
+            return `${minutes}m`;
+        if (minutes < 1440) {
+            const h = Math.floor(minutes / 60);
+            const m = minutes % 60;
+            return m > 0 ? `${h}h${m}m` : `${h}h`;
+        }
+        const d = Math.floor(minutes / 1440);
+        const h = Math.floor((minutes % 1440) / 60);
+        return h > 0 ? `${d}d${h}h` : `${d}d`;
+    }
+    /** Parse a cron expression and return the next run Date. */
+    function getNextCronRun(schedule) {
+        try {
+            // node-cron uses 6-field (with seconds) or 5-field; cron-parser expects 5-field
+            const fields = schedule.trim().split(/\s+/);
+            // If 6 fields, drop the leading seconds field
+            const expr = fields.length === 6 ? fields.slice(1).join(' ') : schedule;
+            const interval = cronParser.CronExpressionParser.parse(expr);
+            return interval.next().toDate();
+        }
+        catch {
+            return null;
+        }
+    }
+    async function sendOrUpdateStatusEmbed(channel) {
+        try {
+            const embed = buildStatusEmbed();
+            if (statusEmbedMessage) {
+                // Edit existing message in-place
+                try {
+                    await statusEmbedMessage.edit({ embeds: [embed] });
+                    return;
+                }
+                catch {
+                    // Message might have been deleted — send a new one
+                    statusEmbedMessage = null;
+                }
+            }
+            const target = channel ?? cachedDmChannel;
+            if (target && 'send' in target) {
+                statusEmbedMessage = await target.send({ embeds: [embed] });
+                // Pin the status message so it's easy to find
+                try {
+                    await statusEmbedMessage.pin();
+                }
+                catch { /* may already be pinned or lack perms */ }
+            }
+        }
+        catch (err) {
+            logger.error({ err }, 'Failed to update status embed');
+        }
+    }
+    /** Send a fresh embed as a new message (does not edit the previous one). */
+    async function sendFreshStatusEmbed(channel) {
+        try {
+            const embed = buildStatusEmbed();
+            if ('send' in channel) {
+                // Unpin old status message if it exists
+                if (statusEmbedMessage) {
+                    try {
+                        await statusEmbedMessage.unpin();
+                    }
+                    catch { /* non-fatal */ }
+                }
+                statusEmbedMessage = await channel.send({ embeds: [embed] });
+                try {
+                    await statusEmbedMessage.pin();
+                }
+                catch { /* non-fatal */ }
+            }
+        }
+        catch (err) {
+            logger.error({ err }, 'Failed to send fresh status embed');
+        }
+    }
+    // Prevent unhandled 'error' events from crashing the process
+    client.on(Events.Error, (err) => {
+        logger.error({ err }, 'Discord client error — will attempt to reconnect');
+    });
+    client.once(Events.ClientReady, async (readyClient) => {
+        logger.info(`${ASSISTANT_NAME} online as ${readyClient.user.tag}`);
+        // Register slash commands (global — takes up to 1hr to propagate, but works in DMs)
+        try {
+            const rest = new REST().setToken(DISCORD_TOKEN);
+            await rest.put(Routes.applicationCommands(readyClient.user.id), { body: slashCommands.map(c => c.toJSON()) });
+            logger.info(`Registered ${slashCommands.length} slash commands`);
+        }
+        catch (err) {
+            logger.error({ err }, 'Failed to register slash commands');
+        }
+        updatePresence();
+        // Auto-send status embed to owner's DMs on startup
+        try {
+            const owner = await client.users.fetch(DISCORD_OWNER_ID, { force: true });
+            const dmChannel = await owner.createDM();
+            cachedDmChannel = dmChannel;
+            await sendOrUpdateStatusEmbed(dmChannel);
+            logger.info('Sent startup status embed to owner DMs');
+        }
+        catch (err) {
+            logger.error({ err }, 'Failed to send startup status embed');
+        }
+        // Event-driven embed updates — debounced to avoid API spam
+        cronScheduler.onStatusChange(() => {
+            if (statusEmbedDebounce)
+                clearTimeout(statusEmbedDebounce);
+            statusEmbedDebounce = setTimeout(() => {
+                sendOrUpdateStatusEmbed().catch(() => { });
+            }, 2000);
+        });
+    });
+    client.on(Events.MessageCreate, async (message) => {
+        try {
+            // Ignore own messages
+            if (message.author.id === client.user?.id)
+                return;
+            // DM or watched guild channel
+            const isDm = message.channel.isDMBased();
+            const isWatchedChannel = !isDm && watchedChannels.has(message.channelId);
+            if (!isDm && !isWatchedChannel)
+                return;
+            // Cache the DM channel for cron/heartbeat notifications
+            if (isDm)
+                cachedDmChannel = message.channel;
+            // Owner-only (applies to both DM and watched channels)
+            if (DISCORD_OWNER_ID && message.author.id !== DISCORD_OWNER_ID) {
+                logger.warn(`Ignored message from non-owner: ${message.author.tag} (${message.author.id})`);
+                return;
+            }
+            // Extract attachments (images and files)
+            let text = message.content;
+            if (message.attachments.size > 0) {
+                const attachmentLines = message.attachments.map(att => {
+                    if (att.contentType?.startsWith('image/')) {
+                        return `[Image attached: ${att.name} (${att.url})]`;
+                    }
+                    return `[File attached: ${att.name}, ${att.contentType || 'unknown type'}, ${att.url}]`;
+                });
+                text = attachmentLines.join('\n') + (text ? '\n' + text : '');
+            }
+            const sessionKey = isWatchedChannel
+                ? `discord:channel:${message.channelId}:${message.author.id}`
+                : `discord:user:${message.author.id}`;
+            // ── Commands (DM only) ──────────────────────────────────────────
+            if (isDm && text === '!clear') {
+                gateway.clearSession(sessionKey);
+                await message.reply('Session cleared.');
+                updatePresence(sessionKey);
+                return;
+            }
+            if (isDm && (text === '!help' || text === '!h')) {
+                await message.reply(handleHelp());
+                return;
+            }
+            if (isDm && text.startsWith('!model')) {
+                const parts = text.split(/\s+/);
+                await message.reply(handleModelSwitch(gateway, sessionKey, parts[1]));
+                updatePresence(sessionKey);
+                return;
+            }
+            if (isDm && text.startsWith('!verbose')) {
+                const parts = text.split(/\s+/);
+                const level = parts[1]?.toLowerCase();
+                if (level === 'quiet' || level === 'normal' || level === 'detailed') {
+                    gateway.setSessionVerboseLevel(sessionKey, level);
+                    await message.reply(`Verbose level set to **${level}**.`);
+                }
+                else {
+                    const current = gateway.getSessionVerboseLevel(sessionKey) ?? 'normal';
+                    await message.reply(`Current verbose level: **${current}**\nOptions: \`!verbose quiet\`, \`!verbose normal\`, \`!verbose detailed\``);
+                }
+                return;
+            }
+            if (isDm && text === '!tools') {
+                await message.reply(formatToolsList());
+                return;
+            }
+            if (isDm && text === '!heartbeat') {
+                const streamer = new DiscordStreamingMessage(message.channel);
+                await streamer.start();
+                const response = await heartbeat.runManual();
+                await streamer.finalize(response);
+                // Inject into DM session so follow-up conversation has context
+                gateway.injectContext(sessionKey, '!heartbeat', response);
+                return;
+            }
+            if (isDm && text.startsWith('!status')) {
+                const parts = text.split(/\s+/);
+                const jobName = parts.slice(1).join(' ') || undefined;
+                await message.reply(handleUnleashedStatus(jobName));
+                return;
+            }
+            if (isDm && text.startsWith('!project')) {
+                const parts = text.split(/\s+/);
+                const subCmd = parts[1]?.toLowerCase();
+                if (subCmd === 'list' || subCmd === 'clear' || subCmd === 'status') {
+                    await message.reply(handleProjectCommand(gateway, sessionKey, subCmd, undefined));
+                }
+                else {
+                    // !project <name> → set project
+                    const projectName = parts.slice(1).join(' ');
+                    await message.reply(handleProjectCommand(gateway, sessionKey, 'set', projectName || undefined));
+                }
+                updatePresence(sessionKey);
+                return;
+            }
+            if (isDm && text.startsWith('!cron')) {
+                const parts = text.split(/\s+/);
+                const subCmd = parts[1]?.toLowerCase();
+                const jobName = parts.slice(2).join(' ');
+                const immediateResult = handleCronCommand(cronScheduler, subCmd, jobName);
+                if (immediateResult !== null) {
+                    await message.reply(immediateResult);
+                    return;
+                }
+                // Handle 'run' — async with streaming
+                const job = cronScheduler.getJob(jobName);
+                if (!job) {
+                    await message.reply(`Cron job '${jobName}' not found. Use \`!cron list\` to see available jobs.`);
+                }
+                else if (cronScheduler.isJobRunning(jobName)) {
+                    await message.reply(`Cron job '${jobName}' is already running.`);
+                }
+                else if (job.mode === 'unleashed') {
+                    // Unleashed tasks run in background — don't block the channel
+                    await message.reply(`Unleashed task "${jobName}" started in background (max ${job.maxHours ?? 6}h). Check the dashboard for progress.`);
+                    cronScheduler.runManual(jobName).then((result) => {
+                        message.reply(`**[Unleashed: ${jobName} — done]**\n\n${result.slice(0, 1800)}`).catch(() => { });
+                        gateway.injectContext(sessionKey, `!cron run ${jobName}`, result);
+                    }).catch((err) => {
+                        message.reply(`**[Unleashed: ${jobName} — error]**\n\n${err}`).catch(() => { });
+                    });
+                }
+                else {
+                    const streamer = new DiscordStreamingMessage(message.channel);
+                    await streamer.start();
+                    const response = await cronScheduler.runManual(jobName);
+                    await streamer.finalize(response);
+                    // Inject into DM session so follow-up conversation has context
+                    gateway.injectContext(sessionKey, `!cron run ${jobName}`, response);
+                }
+                return;
+            }
+            // ── Workflow command (DM only) ──────────────────────────────────
+            if (isDm && text.startsWith('!workflow')) {
+                const parts = text.split(/\s+/);
+                const subCmd = parts[1]?.toLowerCase();
+                if (subCmd === 'list' || !subCmd) {
+                    await message.reply(cronScheduler.listWorkflows());
+                    return;
+                }
+                if (subCmd === 'run') {
+                    const rest = parts.slice(2).join(' ');
+                    // Parse "name key=val key=val"
+                    const tokens = rest.split(/\s+/);
+                    const wfName = tokens[0];
+                    if (!wfName) {
+                        await message.reply('Usage: `!workflow run <name> [key=val ...]`');
+                        return;
+                    }
+                    const wf = cronScheduler.getWorkflow(wfName);
+                    if (!wf) {
+                        await message.reply(`Workflow '${wfName}' not found. Use \`!workflow list\` to see available workflows.`);
+                        return;
+                    }
+                    if (cronScheduler.isWorkflowRunning(wfName)) {
+                        await message.reply(`Workflow '${wfName}' is already running.`);
+                        return;
+                    }
+                    // Parse input overrides
+                    const inputs = {};
+                    for (const token of tokens.slice(1)) {
+                        const eq = token.indexOf('=');
+                        if (eq > 0) {
+                            inputs[token.slice(0, eq)] = token.slice(eq + 1);
+                        }
+                    }
+                    const streamer = new DiscordStreamingMessage(message.channel);
+                    await streamer.start();
+                    const response = await cronScheduler.runWorkflow(wfName, inputs);
+                    await streamer.finalize(response);
+                    gateway.injectContext(sessionKey, `!workflow run ${wfName}`, response);
+                    return;
+                }
+                await message.reply('Usage: `!workflow list` or `!workflow run <name> [key=val ...]`');
+                return;
+            }
+            // ── Live status embed (DM only) ────────────────────────────────────
+            if (isDm && text === '!dashboard') {
+                await sendFreshStatusEmbed(message.channel);
+                return;
+            }
+            // ── Self-Improvement command (DM only) ────────────────────────────
+            if (isDm && text.startsWith('!self-improve')) {
+                const parts = text.split(/\s+/);
+                const subCmd = parts[1]?.toLowerCase();
+                if (subCmd === 'status' || !subCmd) {
+                    const result = await gateway.handleSelfImprove('status');
+                    await message.reply(result);
+                    return;
+                }
+                if (subCmd === 'history') {
+                    const result = await gateway.handleSelfImprove('history');
+                    await message.reply(result || 'No experiment history yet.');
+                    return;
+                }
+                if (subCmd === 'pending') {
+                    const result = await gateway.handleSelfImprove('pending');
+                    await message.reply(result);
+                    return;
+                }
+                if (subCmd === 'apply') {
+                    const expId = parts[2];
+                    if (!expId) {
+                        await message.reply('Usage: `!self-improve apply <experiment-id>`');
+                        return;
+                    }
+                    const result = await gateway.handleSelfImprove('apply', { experimentId: expId });
+                    await message.reply(result);
+                    return;
+                }
+                if (subCmd === 'deny') {
+                    const expId = parts[2];
+                    if (!expId) {
+                        await message.reply('Usage: `!self-improve deny <experiment-id>`');
+                        return;
+                    }
+                    const result = await gateway.handleSelfImprove('deny', { experimentId: expId });
+                    await message.reply(result);
+                    return;
+                }
+                if (subCmd === 'run') {
+                    const streamer = new DiscordStreamingMessage(message.channel);
+                    await streamer.start();
+                    const result = await gateway.handleSelfImprove('run', {}, async (experiment) => {
+                        // Send proposal embed for each accepted experiment
+                        const proposalText = `**Self-Improvement Proposal #${experiment.iteration}**\n\n` +
+                            `**Area:** ${experiment.area}\n` +
+                            `**Target:** ${experiment.target}\n` +
+                            `**Score:** ${(experiment.score * 10).toFixed(1)}/10\n\n` +
+                            `**Hypothesis:** ${experiment.hypothesis}\n\n` +
+                            `**Proposed Change:**\n\`\`\`\n${experiment.proposedChange.slice(0, 800)}\n\`\`\``;
+                        await sendApprovalButtons(message.channel, proposalText.slice(0, 1900), 'si', experiment.id);
+                    });
+                    await streamer.finalize(result);
+                    return;
+                }
+                await message.reply('**Self-Improvement Commands:**\n' +
+                    '`!self-improve run` — trigger a self-improvement cycle\n' +
+                    '`!self-improve status` — show current state and baseline metrics\n' +
+                    '`!self-improve history [n]` — show last N experiments (default 10)\n' +
+                    '`!self-improve pending` — list pending approval proposals\n' +
+                    '`!self-improve apply <id>` — approve a pending change\n' +
+                    '`!self-improve deny <id>` — deny a pending change');
+                return;
+            }
+            // ── Skill approval shortcuts (DM only) ──────────────────────────
+            // Natural language: "approve skill <name>" / "reject skill <name>" (from notification prompts)
+            // Explicit: "!skill pending|approve <name>|reject <name>"
+            if (isDm) {
+                const lc = text.toLowerCase().trim();
+                if (lc.startsWith('approve skill ') || lc.startsWith('reject skill ')) {
+                    const isApprove = lc.startsWith('approve skill ');
+                    const skillName = text.trim().split(/\s+/)[2];
+                    if (skillName) {
+                        const result = await gateway.handleSkill(isApprove ? 'approve' : 'reject', { name: skillName });
+                        await message.reply(result);
+                        return;
+                    }
+                }
+                if (lc.startsWith('!skill')) {
+                    const parts = text.split(/\s+/);
+                    const subCmd = parts[1]?.toLowerCase();
+                    if (!subCmd || subCmd === 'pending') {
+                        const result = await gateway.handleSkill('pending');
+                        await message.reply(result);
+                        return;
+                    }
+                    if (subCmd === 'approve') {
+                        const name = parts[2];
+                        if (!name) {
+                            await message.reply('Usage: `!skill approve <name>`');
+                            return;
+                        }
+                        const result = await gateway.handleSkill('approve', { name });
+                        await message.reply(result);
+                        return;
+                    }
+                    if (subCmd === 'reject') {
+                        const name = parts[2];
+                        if (!name) {
+                            await message.reply('Usage: `!skill reject <name>`');
+                            return;
+                        }
+                        const result = await gateway.handleSkill('reject', { name });
+                        await message.reply(result);
+                        return;
+                    }
+                    await message.reply('**Skill Commands:**\n' +
+                        '`!skill pending` — list skills waiting for approval\n' +
+                        '`!skill approve <name>` — activate a pending skill\n' +
+                        '`!skill reject <name>` — discard a pending skill');
+                    return;
+                }
+            }
+            // ── Team commands (DM only) ─────────────────────────────────────
+            if (isDm && text.startsWith('!team')) {
+                const parts = text.split(/\s+/);
+                const subCmd = parts[1]?.toLowerCase();
+                if (subCmd === 'list' || !subCmd) {
+                    const router = gateway.getTeamRouter();
+                    const agents = router.listTeamAgents();
+                    if (agents.length === 0) {
+                        await message.reply('No team agents configured. Hire one from the dashboard or add a profile to `vault/00-System/agents/`.');
+                    }
+                    else {
+                        const statuses = botManager?.getStatuses() ?? new Map();
+                        const lines = ['**Team Agents:**\n'];
+                        for (const a of agents) {
+                            const bs = statuses.get(a.slug);
+                            const statusIcon = bs?.status === 'online' ? '\u{1F7E2}' : bs?.status === 'connecting' ? '\u{1F7E1}' : bs?.status === 'error' ? '\u{1F534}' : '\u26AB';
+                            const statusText = bs?.status ?? 'offline';
+                            const targets = a.team?.canMessage.join(', ') || 'none';
+                            lines.push(`- ${statusIcon} **${a.name}** (\`${a.slug}\`) — ${statusText}`);
+                            const chName = a.team?.channelName;
+                            const chDisplay = chName ? (Array.isArray(chName) ? chName.map(c => '#' + c).join(', ') : '#' + chName) : 'none';
+                            lines.push(`  Channel: ${chDisplay} · Can message: ${targets}`);
+                        }
+                        await message.reply(lines.join('\n'));
+                    }
+                    return;
+                }
+                if (subCmd === 'status') {
+                    const router = gateway.getTeamRouter();
+                    const agents = router.listTeamAgents();
+                    const statuses = botManager?.getStatuses() ?? new Map();
+                    const onlineCount = Array.from(statuses.values()).filter(s => s.status === 'online').length;
+                    const msgs = gateway.getTeamBus().getRecentMessages(10);
+                    const lines = [`**Team Status** — ${agents.length} agent(s), ${onlineCount} online\n`];
+                    for (const a of agents) {
+                        const bs = statuses.get(a.slug);
+                        const icon = bs?.status === 'online' ? '\u2705' : '\u274c';
+                        const agentMsgs = msgs.filter(m => m.fromAgent === a.slug || m.toAgent === a.slug);
+                        lines.push(`${icon} **${a.name}**: ${bs?.status ?? 'offline'} · ${agentMsgs.length} recent message(s)`);
+                    }
+                    await message.reply(lines.join('\n') || 'No team agents configured.');
+                    return;
+                }
+                if (subCmd === 'messages') {
+                    const count = parseInt(parts[2] || '10', 10);
+                    const msgs = gateway.getTeamBus().getRecentMessages(Math.min(count, 50));
+                    if (msgs.length === 0) {
+                        await message.reply('No inter-agent messages yet.');
+                    }
+                    else {
+                        const lines = msgs.map(m => `\`${m.timestamp.slice(11, 19)}\` **${m.fromAgent}** \u2192 **${m.toAgent}**: ${m.content.slice(0, 100)}`);
+                        await message.reply(`**Recent Team Messages:**\n\n${lines.join('\n')}`);
+                    }
+                    return;
+                }
+                if (subCmd === 'topology') {
+                    const { nodes, edges } = gateway.getTeamRouter().getTopology();
+                    if (nodes.length === 0) {
+                        await message.reply('No team agents configured.');
+                    }
+                    else {
+                        const lines = ['**Team Topology:**\n'];
+                        for (const node of nodes) {
+                            const outgoing = edges.filter(e => e.from === node.slug).map(e => e.to);
+                            lines.push(`- **${node.name}** \u2192 ${outgoing.length > 0 ? outgoing.join(', ') : '(no outgoing)'}`);
+                        }
+                        await message.reply(lines.join('\n'));
+                    }
+                    return;
+                }
+                await message.reply('**Team Commands:**\n' +
+                    '`!team setup` — auto-create Discord channels for all team agents\n' +
+                    '`!team list` — list all team agents and their channels\n' +
+                    '`!team status` — show agent status\n' +
+                    '`!team messages [n]` — recent inter-agent messages\n' +
+                    '`!team topology` — communication graph');
+                return;
+            }
+            // ── Plan orchestration (DM only) ─────────────────────────────────
+            if (isDm && text.startsWith('!plan ')) {
+                const taskDescription = text.slice(6).trim();
+                if (!taskDescription) {
+                    await message.reply('Usage: `!plan <task description>`');
+                    return;
+                }
+                await handlePlanCommand(gateway, sessionKey, taskDescription, message.channel);
+                return;
+            }
+            // ── Approval responses (DM only) ────────────────────────────────
+            if (isDm) {
+                const lower = text.toLowerCase();
+                if (['yes', 'no', 'approve', 'deny', 'go', 'skip', 'always'].includes(lower)) {
+                    const approvals = gateway.getPendingApprovals();
+                    if (approvals.length > 0) {
+                        // Pass 'always' as a string so the check-in gate can persist the channel
+                        const result = lower === 'always' ? 'always' :
+                            (lower === 'yes' || lower === 'approve' || lower === 'go');
+                        gateway.resolveApproval(approvals[approvals.length - 1], result);
+                        await message.react(lower === 'no' || lower === 'deny' || lower === 'skip' ? '\u274c' : '\u2705');
+                        return;
+                    }
+                }
+            }
+            // ── Per-message model/mode prefix ──────────────────────────────
+            let effectiveText = text;
+            let oneOffModel;
+            let oneOffMaxTurns;
+            if (text.startsWith('!q ')) {
+                oneOffModel = MODELS.haiku;
+                effectiveText = text.slice(3);
+            }
+            else if (text.startsWith('!d ')) {
+                oneOffModel = MODELS.opus;
+                effectiveText = text.slice(3);
+            }
+            else if (isDm && text.startsWith('!deep ')) {
+                // Deep mode requires approval before running 100 turns
+                const deepMsg = text.slice(6).trim();
+                if (!deepMsg) {
+                    await message.reply('Usage: `!deep <message>`');
+                    return;
+                }
+                const requestId = `deep-${Date.now()}`;
+                await sendApprovalButtons(message.channel, `**Deep mode** (100 turns) requested for:\n_${deepMsg.slice(0, 200)}_\n\nApprove?`, 'deep', requestId);
+                const approved = await gateway.requestApproval('Pending approval', requestId);
+                if (!approved) {
+                    await message.reply('Deep mode cancelled.');
+                    return;
+                }
+                oneOffMaxTurns = 100;
+                effectiveText = deepMsg;
+            }
+            // ── Reply context for watched channels ─────────────────────────
+            if (isWatchedChannel && message.reference?.messageId) {
+                try {
+                    const referenced = await message.channel.messages.fetch(message.reference.messageId);
+                    if (referenced.author.id === client.user?.id) {
+                        const refContent = referenced.content.slice(0, 1500);
+                        effectiveText = `[Replying to bot message:\n${refContent}]\n\n${effectiveText}`;
+                    }
+                }
+                catch { /* referenced message may be deleted */ }
+            }
+            // ── !stop — abort active query (bypasses session lock) ────────────
+            if (isDm && (text === '!stop' || text === '/stop')) {
+                const stopped = gateway.stopSession(sessionKey);
+                await message.reply(stopped ? 'Stopping...' : 'Nothing running to stop.');
+                return;
+            }
+            // ── Show queued indicator if session is busy ─────────────────────
+            if (gateway.isSessionBusy(sessionKey)) {
+                await message.react('\u23f3'); // hourglass
+            }
+            // ── Stream response ─────────────────────────────────────────────
+            const streamer = new DiscordStreamingMessage(message.channel);
+            await streamer.start();
+            try {
+                const response = await gateway.handleMessage(sessionKey, effectiveText, (t) => streamer.update(t), oneOffModel, oneOffMaxTurns, (toolName, toolInput) => { streamer.setToolStatus(friendlyToolName(toolName, toolInput)); return Promise.resolve(); });
+                await streamer.finalize(response);
+                updatePresence(sessionKey);
+                // Track bot message for feedback reactions
+                if (streamer.messageId) {
+                    trackBotMessage(streamer.messageId, {
+                        sessionKey,
+                        userMessage: effectiveText.slice(0, 500),
+                        botResponse: response.slice(0, 500),
+                    });
+                }
+            }
+            catch (err) {
+                logger.error({ err }, 'Error processing Discord message');
+                await streamer.finalize(`Something went wrong: ${err}`);
+            }
+        }
+        catch (err) {
+            logger.error({ err }, 'Unhandled error in Discord message handler');
+        }
+    });
+    // ── Slash command + button interaction handler ──────────────────────
+    client.on(Events.InteractionCreate, async (interaction) => {
+        try {
+            // ── Autocomplete ────────────────────────────────────────────────
+            if (interaction.isAutocomplete()) {
+                if (interaction.commandName === 'project') {
+                    const focused = interaction.options.getFocused().toLowerCase();
+                    const projects = getLinkedProjects().map(p => path.basename(p.path));
+                    const filtered = projects
+                        .filter(name => name.toLowerCase().includes(focused))
+                        .slice(0, 25);
+                    await interaction.respond(filtered.map(name => ({ name, value: name })));
+                }
+                else if (interaction.commandName === 'cron') {
+                    const focused = interaction.options.getFocused().toLowerCase();
+                    const jobNames = cronScheduler.getJobNames();
+                    const filtered = jobNames
+                        .filter(name => name.toLowerCase().includes(focused))
+                        .slice(0, 25);
+                    await interaction.respond(filtered.map(name => ({ name, value: name })));
+                }
+                else if (interaction.commandName === 'workflow') {
+                    const focused = interaction.options.getFocused().toLowerCase();
+                    const wfNames = cronScheduler.getWorkflowNames();
+                    const filtered = wfNames
+                        .filter(name => name.toLowerCase().includes(focused))
+                        .slice(0, 25);
+                    await interaction.respond(filtered.map(name => ({ name, value: name })));
+                }
+                return;
+            }
+            // ── Slash commands ───────────────────────────────────────────────
+            if (interaction.isChatInputCommand()) {
+                const cmd = interaction;
+                // Owner-only guard
+                if (DISCORD_OWNER_ID && cmd.user.id !== DISCORD_OWNER_ID) {
+                    await cmd.reply({ content: 'Owner only.', ephemeral: true });
+                    return;
+                }
+                // Cache DM channel for notifications
+                if (cmd.channel?.isDMBased())
+                    cachedDmChannel = cmd.channel;
+                const sessionKey = cmd.channel?.isDMBased()
+                    ? `discord:user:${cmd.user.id}`
+                    : `discord:channel:${cmd.channelId}:${cmd.user.id}`;
+                const name = cmd.commandName;
+                // Simple immediate-response commands
+                if (name === 'help') {
+                    await cmd.reply(handleHelp());
+                    return;
+                }
+                if (name === 'clear') {
+                    gateway.clearSession(sessionKey);
+                    await cmd.reply('Session cleared.');
+                    updatePresence(sessionKey);
+                    return;
+                }
+                if (name === 'tools') {
+                    await cmd.reply(formatToolsList());
+                    return;
+                }
+                if (name === 'status') {
+                    const jobArg = cmd.options.getString('job') ?? undefined;
+                    await cmd.reply(handleUnleashedStatus(jobArg));
+                    return;
+                }
+                if (name === 'model') {
+                    const tier = cmd.options.getString('tier', true);
+                    await cmd.reply(handleModelSwitch(gateway, sessionKey, tier));
+                    updatePresence(sessionKey);
+                    return;
+                }
+                if (name === 'verbose') {
+                    const level = cmd.options.getString('level', true);
+                    gateway.setSessionVerboseLevel(sessionKey, level);
+                    await cmd.reply({ content: `Verbose level set to **${level}**.`, ephemeral: true });
+                    return;
+                }
+                if (name === 'project') {
+                    const action = cmd.options.getString('action', true);
+                    const projName = cmd.options.getString('name') ?? undefined;
+                    await cmd.reply(handleProjectCommand(gateway, sessionKey, action, projName));
+                    updatePresence(sessionKey);
+                    return;
+                }
+                // Team command
+                if (name === 'team') {
+                    const action = cmd.options.getString('action', true);
+                    if (action === 'list') {
+                        const router = gateway.getTeamRouter();
+                        const agents = router.listTeamAgents();
+                        if (agents.length === 0) {
+                            await cmd.reply({ content: 'No team agents configured.', ephemeral: true });
+                        }
+                        else {
+                            const statuses = botManager?.getStatuses() ?? new Map();
+                            const lines = agents.map(a => {
+                                const bs = statuses.get(a.slug);
+                                const icon = bs?.status === 'online' ? '\u{1F7E2}' : bs?.status === 'connecting' ? '\u{1F7E1}' : bs?.status === 'error' ? '\u{1F534}' : '\u26AB';
+                                return `${icon} **${a.name}** (\`${a.slug}\`) \u2014 ${bs?.status ?? 'offline'}`;
+                            });
+                            await cmd.reply({ content: `**Team Agents:**\n${lines.join('\n')}`, ephemeral: true });
+                        }
+                        return;
+                    }
+                    if (action === 'status') {
+                        const router = gateway.getTeamRouter();
+                        const agents = router.listTeamAgents();
+                        const statuses = botManager?.getStatuses() ?? new Map();
+                        const onlineCount = Array.from(statuses.values()).filter(s => s.status === 'online').length;
+                        const msgs = gateway.getTeamBus().getRecentMessages(10);
+                        const lines = [`**Team Status** \u2014 ${agents.length} agent(s), ${onlineCount} online\n`];
+                        for (const a of agents) {
+                            const bs = statuses.get(a.slug);
+                            const icon = bs?.status === 'online' ? '\u2705' : '\u274c';
+                            const agentMsgs = msgs.filter(m => m.fromAgent === a.slug || m.toAgent === a.slug);
+                            lines.push(`${icon} **${a.name}**: ${bs?.status ?? 'offline'} \u00b7 ${agentMsgs.length} recent message(s)`);
+                        }
+                        await cmd.reply({ content: lines.join('\n'), ephemeral: true });
+                        return;
+                    }
+                    if (action === 'messages') {
+                        const msgs = gateway.getTeamBus().getRecentMessages(10);
+                        if (msgs.length === 0) {
+                            await cmd.reply({ content: 'No inter-agent messages yet.', ephemeral: true });
+                        }
+                        else {
+                            const lines = msgs.map(m => `\`${m.timestamp.slice(11, 19)}\` **${m.fromAgent}** \u2192 **${m.toAgent}**: ${m.content.slice(0, 100)}`);
+                            await cmd.reply({ content: lines.join('\n'), ephemeral: true });
+                        }
+                        return;
+                    }
+                    if (action === 'topology') {
+                        const { nodes, edges } = gateway.getTeamRouter().getTopology();
+                        if (nodes.length === 0) {
+                            await cmd.reply({ content: 'No team agents configured.', ephemeral: true });
+                        }
+                        else {
+                            const lines = nodes.map(node => {
+                                const outgoing = edges.filter(e => e.from === node.slug).map(e => e.to);
+                                return `**${node.name}** \u2192 ${outgoing.length > 0 ? outgoing.join(', ') : '(none)'}`;
+                            });
+                            await cmd.reply({ content: `**Topology:**\n${lines.join('\n')}`, ephemeral: true });
+                        }
+                        return;
+                    }
+                    await cmd.reply({ content: 'Unknown team action.', ephemeral: true });
+                    return;
+                }
+                // Cron command
+                if (name === 'cron') {
+                    const action = cmd.options.getString('action', true);
+                    const jobName = cmd.options.getString('job') ?? '';
+                    const immediateResult = handleCronCommand(cronScheduler, action, jobName);
+                    if (immediateResult !== null) {
+                        await cmd.reply(immediateResult);
+                        return;
+                    }
+                    // Handle 'run' — async with deferred reply
+                    const job = cronScheduler.getJob(jobName);
+                    if (!job) {
+                        await cmd.reply(`Cron job '${jobName}' not found. Use \`/cron list\` to see available jobs.`);
+                        return;
+                    }
+                    if (cronScheduler.isJobRunning(jobName)) {
+                        await cmd.reply(`Cron job '${jobName}' is already running.`);
+                        return;
+                    }
+                    if (job.mode === 'unleashed') {
+                        await cmd.reply(`Unleashed task "${jobName}" started in background (max ${job.maxHours ?? 6}h). Check the dashboard for progress.`);
+                        cronScheduler.runManual(jobName).then((result) => {
+                            cmd.followUp(`**[Unleashed: ${jobName} — done]**\n\n${result.slice(0, 1800)}`).catch(() => { });
+                            gateway.injectContext(sessionKey, `!cron run ${jobName}`, result);
+                        }).catch((err) => {
+                            cmd.followUp(`**[Unleashed: ${jobName} — error]**\n\n${err}`).catch(() => { });
+                        });
+                        return;
+                    }
+                    await cmd.deferReply();
+                    const response = await cronScheduler.runManual(jobName);
+                    const chunks = chunkText(response || `*(cron job '${jobName}' completed — no output)*`, 1900);
+                    await cmd.editReply(chunks[0]);
+                    for (let i = 1; i < chunks.length; i++) {
+                        await cmd.followUp(chunks[i]);
+                    }
+                    gateway.injectContext(sessionKey, `!cron run ${jobName}`, response);
+                    return;
+                }
+                // Workflow command
+                if (name === 'workflow') {
+                    const action = cmd.options.getString('action', true);
+                    const wfName = cmd.options.getString('name') ?? '';
+                    if (action === 'list') {
+                        await cmd.reply(cronScheduler.listWorkflows());
+                        return;
+                    }
+                    if (action === 'run') {
+                        if (!wfName) {
+                            await cmd.reply('Specify a workflow name.');
+                            return;
+                        }
+                        const wf = cronScheduler.getWorkflow(wfName);
+                        if (!wf) {
+                            await cmd.reply(`Workflow '${wfName}' not found.`);
+                            return;
+                        }
+                        if (cronScheduler.isWorkflowRunning(wfName)) {
+                            await cmd.reply(`Workflow '${wfName}' is already running.`);
+                            return;
+                        }
+                        // Parse input overrides from the inputs string
+                        const inputsStr = cmd.options.getString('inputs') ?? '';
+                        const inputs = {};
+                        for (const token of inputsStr.split(/\s+/).filter(Boolean)) {
+                            const eq = token.indexOf('=');
+                            if (eq > 0) {
+                                inputs[token.slice(0, eq)] = token.slice(eq + 1);
+                            }
+                        }
+                        await cmd.deferReply();
+                        const response = await cronScheduler.runWorkflow(wfName, inputs);
+                        const chunks = chunkText(response || `*(workflow '${wfName}' completed — no output)*`, 1900);
+                        await cmd.editReply(chunks[0]);
+                        for (let i = 1; i < chunks.length; i++) {
+                            await cmd.followUp(chunks[i]);
+                        }
+                        gateway.injectContext(sessionKey, `!workflow run ${wfName}`, response);
+                        return;
+                    }
+                    return;
+                }
+                // Self-improve command
+                if (name === 'self-improve') {
+                    const subCmd = cmd.options.getSubcommand();
+                    if (subCmd === 'status') {
+                        const result = await gateway.handleSelfImprove('status');
+                        await cmd.reply({ content: result, ephemeral: true });
+                        return;
+                    }
+                    if (subCmd === 'history') {
+                        const result = await gateway.handleSelfImprove('history');
+                        await cmd.reply({ content: result || 'No history yet.', ephemeral: true });
+                        return;
+                    }
+                    if (subCmd === 'pending') {
+                        const result = await gateway.handleSelfImprove('pending');
+                        await cmd.reply({ content: result, ephemeral: true });
+                        return;
+                    }
+                    if (subCmd === 'run') {
+                        await cmd.deferReply();
+                        const result = await gateway.handleSelfImprove('run', {}, async (experiment) => {
+                            const proposalText = `**Self-Improvement Proposal #${experiment.iteration}**\n\n` +
+                                `**Area:** ${experiment.area}\n` +
+                                `**Target:** ${experiment.target}\n` +
+                                `**Score:** ${(experiment.score * 10).toFixed(1)}/10\n\n` +
+                                `**Hypothesis:** ${experiment.hypothesis}\n\n` +
+                                `**Proposed Change:**\n\`\`\`\n${experiment.proposedChange.slice(0, 800)}\n\`\`\``;
+                            if (cmd.channel) {
+                                await sendApprovalButtons(cmd.channel, proposalText.slice(0, 1900), 'si', experiment.id);
+                            }
+                        });
+                        const chunks = chunkText(result, 1900);
+                        await cmd.editReply(chunks[0]);
+                        for (let i = 1; i < chunks.length; i++) {
+                            await cmd.followUp(chunks[i]);
+                        }
+                        return;
+                    }
+                    return;
+                }
+                // Dashboard — fresh status embed
+                if (name === 'dashboard') {
+                    if (cmd.channel) {
+                        await cmd.reply({ content: 'Refreshing status...', ephemeral: true });
+                        await sendFreshStatusEmbed(cmd.channel);
+                    }
+                    else {
+                        await cmd.reply({ content: 'Could not access channel.', ephemeral: true });
+                    }
+                    return;
+                }
+                // Heartbeat command
+                if (name === 'heartbeat') {
+                    await cmd.deferReply();
+                    const response = await heartbeat.runManual();
+                    const chunks = chunkText(response, 1900);
+                    await cmd.editReply(chunks[0]);
+                    for (let i = 1; i < chunks.length; i++) {
+                        await cmd.followUp(chunks[i]);
+                    }
+                    gateway.injectContext(sessionKey, '!heartbeat', response);
+                    return;
+                }
+                // Plan command — uses same approval-gated function as !plan
+                if (name === 'plan') {
+                    const task = cmd.options.getString('task', true);
+                    await cmd.deferReply();
+                    await cmd.editReply(`Planning: _${task.slice(0, 100)}_...`);
+                    // Route through the shared handlePlanCommand (it handles approval + progress)
+                    // We need the channel for buttons, so get it from the interaction
+                    if (cmd.channel) {
+                        await handlePlanCommand(gateway, sessionKey, task, cmd.channel);
+                    }
+                    else {
+                        await cmd.editReply('Could not access channel for plan approval.');
+                    }
+                    return;
+                }
+                // Chat commands: /deep (with approval), /quick, /opus
+                if (name === 'deep' || name === 'quick' || name === 'opus') {
+                    const msg = cmd.options.getString('message', true);
+                    const oneOffModel = name === 'quick' ? MODELS.haiku : name === 'opus' ? MODELS.opus : undefined;
+                    const oneOffMaxTurns = name === 'deep' ? 100 : undefined;
+                    // /deep requires approval before running 100 turns
+                    if (name === 'deep' && cmd.channel) {
+                        await cmd.deferReply();
+                        await cmd.editReply(`**Deep mode** (100 turns) requested for:\n_${msg.slice(0, 200)}_`);
+                        const requestId = `deep-${Date.now()}`;
+                        await sendApprovalButtons(cmd.channel, 'Approve deep mode?', 'deep', requestId);
+                        const approved = await gateway.requestApproval('Pending approval', requestId);
+                        if (!approved) {
+                            await cmd.followUp('Deep mode cancelled.');
+                            return;
+                        }
+                    }
+                    else {
+                        await cmd.deferReply();
+                    }
+                    try {
+                        const response = await gateway.handleMessage(sessionKey, msg, async () => { }, oneOffModel, oneOffMaxTurns);
+                        const chunks = chunkText(response || '*(no response)*', 1900);
+                        if (name === 'deep') {
+                            // Deep mode already has a deferred reply, use followUp
+                            await cmd.followUp(chunks[0]);
+                            for (let i = 1; i < chunks.length; i++) {
+                                await cmd.followUp(chunks[i]);
+                            }
+                        }
+                        else {
+                            await cmd.editReply(chunks[0]);
+                            for (let i = 1; i < chunks.length; i++) {
+                                await cmd.followUp(chunks[i]);
+                            }
+                        }
+                    }
+                    catch (err) {
+                        logger.error({ err }, `/${name} command failed`);
+                        const errMsg = `Something went wrong: ${err}`;
+                        if (name === 'deep') {
+                            await cmd.followUp(errMsg);
+                        }
+                        else {
+                            await cmd.editReply(errMsg);
+                        }
+                    }
+                    return;
+                }
+                return;
+            }
+            // ── Modal submissions (revision feedback) ─────────────────────
+            if (interaction.isModalSubmit()) {
+                const modal = interaction;
+                const modalId = modal.customId; // e.g. "revise_modal_plan-1234567890"
+                if (modalId.startsWith('revise_modal_')) {
+                    const requestId = modalId.replace('revise_modal_', '');
+                    const feedback = modal.fields.getTextInputValue('revision_feedback');
+                    await modal.deferUpdate();
+                    // Disable buttons on the original approval message
+                    try {
+                        if (modal.message) {
+                            const originalContent = modal.message.content ?? '';
+                            const rawComponents = modal.message.components.map((row) => ({
+                                type: 1,
+                                components: (row.components ?? []).map((comp) => ({
+                                    type: comp.type ?? 2,
+                                    style: comp.style,
+                                    label: comp.label,
+                                    custom_id: comp.customId ?? comp.custom_id,
+                                    disabled: true,
+                                })),
+                            }));
+                            await modal.editReply({
+                                content: originalContent + `\n\n\u270f\ufe0f **REVISING** by ${modal.user.username}: ${feedback.slice(0, 200)}`,
+                                components: rawComponents,
+                            });
+                        }
+                    }
+                    catch { /* non-fatal */ }
+                    // Resolve the approval gate with the revision feedback string
+                    gateway.resolveApproval(requestId, feedback);
+                    return;
+                }
+            }
+            // ── Button interactions ──────────────────────────────────────────
+            if (!interaction.isButton())
+                return;
+            const button = interaction;
+            // Owner-only
+            if (DISCORD_OWNER_ID && button.user.id !== DISCORD_OWNER_ID) {
+                await button.reply({ content: 'Only the owner can use these buttons.', ephemeral: true });
+                return;
+            }
+            const customId = button.customId; // e.g. "plan_plan-123_approve", "plan_plan-123_revise"
+            const isApprove = customId.endsWith('_approve');
+            const isDeny = customId.endsWith('_deny');
+            const isRevise = customId.endsWith('_revise');
+            if (!isApprove && !isDeny && !isRevise)
+                return;
+            // ── Revise button → show modal for feedback ────────────────────
+            if (isRevise) {
+                const parts = customId.split('_');
+                const requestId = parts.slice(1, -1).join('_');
+                // Show a text input modal to collect revision feedback
+                await button.showModal({
+                    title: 'Revise Plan',
+                    custom_id: `revise_modal_${requestId}`,
+                    components: [{
+                            type: 1, // ActionRow
+                            components: [{
+                                    type: 4, // TextInput
+                                    custom_id: 'revision_feedback',
+                                    label: 'What would you like to change?',
+                                    style: 2, // Paragraph
+                                    placeholder: 'e.g., "Split step 3 into two separate steps" or "Add error handling"',
+                                    required: true,
+                                    max_length: 1000,
+                                }],
+                        }],
+                });
+                return;
+            }
+            const action = isApprove ? 'approved' : 'denied';
+            const emoji = isApprove ? '\u2705' : '\u274c';
+            // Acknowledge immediately — Discord requires response within 3 seconds
+            await button.deferUpdate();
+            // Update the original message: disable buttons and show decision
+            try {
+                const originalContent = button.message.content ?? '';
+                const updatedContent = originalContent + `\n\n${emoji} **${action.toUpperCase()}** by ${button.user.username}`;
+                // Disable buttons via raw API data — avoids discord.js component type issues
+                const rawComponents = button.message.components.map((row) => ({
+                    type: 1,
+                    components: (row.components ?? []).map((comp) => ({
+                        type: comp.type ?? 2,
+                        style: comp.style,
+                        label: comp.label,
+                        custom_id: comp.customId ?? comp.custom_id,
+                        disabled: true,
+                    })),
+                }));
+                await button.editReply({
+                    content: updatedContent.slice(0, 2000),
+                    components: rawComponents,
+                });
+            }
+            catch (err) {
+                logger.error({ err }, 'Failed to update button message');
+            }
+            // ── Plan/Deep approval buttons → resolve the gateway approval gate
+            if (customId.startsWith('plan_') || customId.startsWith('deep_')) {
+                // Extract requestId: "plan_{requestId}_approve" → requestId
+                const parts = customId.split('_');
+                // Remove prefix (plan/deep) and suffix (approve/deny), join middle parts
+                const requestId = parts.slice(1, -1).join('_');
+                gateway.resolveApproval(requestId, isApprove);
+                return;
+            }
+            // ── Self-improvement approval buttons
+            if (customId.startsWith('si_')) {
+                const parts = customId.split('_');
+                const experimentId = parts.slice(1, -1).join('_');
+                try {
+                    const result = isApprove
+                        ? await gateway.handleSelfImprove('apply', { experimentId })
+                        : await gateway.handleSelfImprove('deny', { experimentId });
+                    await button.followUp({ content: result, ephemeral: true });
+                }
+                catch (err) {
+                    await button.followUp({ content: `Error: ${err}`, ephemeral: true });
+                }
+                return;
+            }
+            // ── Other buttons — route the decision to the agent as a message
+            const sessionKey = `discord:channel:${button.channelId}:${button.user.id}`;
+            const originalContent = button.message.content ?? '';
+            // Build context message for the agent
+            const agentMessage = `[Button clicked: ${action}]\n\nOriginal request:\n${originalContent}\n\nNate ${action} this request. ${isApprove ? 'Proceed as requested.' : 'Skip this request and log that it was denied.'}`;
+            // Process through gateway
+            const streamer = new DiscordStreamingMessage(button.channel);
+            await streamer.start();
+            try {
+                const response = await gateway.handleMessage(sessionKey, agentMessage, (t) => streamer.update(t));
+                await streamer.finalize(response);
+            }
+            catch (err) {
+                logger.error({ err }, 'Error processing button interaction');
+                await streamer.finalize(`Something went wrong processing the ${action}: ${err}`);
+            }
+        }
+        catch (err) {
+            logger.error({ err }, 'Unhandled error in Discord interaction handler');
+        }
+    });
+    // ── Reaction-based feedback handler ─────────────────────────────────
+    client.on(Events.MessageReactionAdd, async (reaction, user) => {
+        try {
+            // Ignore bot's own reactions
+            if (user.id === client.user?.id)
+                return;
+            // Owner-only
+            if (DISCORD_OWNER_ID && user.id !== DISCORD_OWNER_ID)
+                return;
+            // Fetch partial reaction if needed
+            if (reaction.partial) {
+                try {
+                    await reaction.fetch();
+                }
+                catch {
+                    return; // Message may have been deleted
+                }
+            }
+            // Check if this is a tracked bot message
+            const messageId = reaction.message.id;
+            const context = botMessageMap.get(messageId);
+            if (!context)
+                return;
+            // Map emoji to rating
+            const emojiName = reaction.emoji.name ?? '';
+            const rating = emojiToRating(emojiName);
+            if (!rating)
+                return;
+            // Log feedback
+            try {
+                const store = await getFeedbackStore();
+                if (store) {
+                    store.logFeedback({
+                        sessionKey: context.sessionKey,
+                        channel: 'discord',
+                        messageSnippet: context.userMessage,
+                        responseSnippet: context.botResponse,
+                        rating,
+                    });
+                    logger.info({ rating, messageId }, 'Feedback logged via Discord reaction');
+                }
+            }
+            catch (err) {
+                logger.warn({ err }, 'Failed to log reaction feedback');
+            }
+        }
+        catch (err) {
+            logger.error({ err }, 'Unhandled error in Discord reaction handler');
+        }
+    });
+    // ── Register notification sender ──────────────────────────────────
+    // Cache the owner's DM channel from successful interactions so
+    // cron/heartbeat notifications don't depend on a fresh API fetch.
+    let cachedDmChannel = null;
+    async function discordNotify(text, context) {
+        // Route to agent bot if available
+        if (context?.agentSlug && botManager?.hasBot(context.agentSlug)) {
+            try {
+                await botManager.sendAsAgent(context.agentSlug, text);
+                logger.info({ agent: context.agentSlug }, 'Notification sent via agent bot');
+                return;
+            }
+            catch (err) {
+                logger.warn({ err, agent: context.agentSlug }, 'Agent bot send failed — falling back to main bot');
+            }
+        }
+        // Main bot: try cached DM channel first
+        let channel = cachedDmChannel;
+        if (!channel || !('send' in channel)) {
+            try {
+                const user = await client.users.fetch(DISCORD_OWNER_ID, { force: true });
+                channel = await user.createDM();
+                cachedDmChannel = channel;
+            }
+            catch (err) {
+                logger.error({ err }, 'Failed to open DM channel for notification');
+                throw err;
+            }
+        }
+        // Send as embed for cron messages, plain text for others
+        const embed = formatCronEmbed(text);
+        const sendContent = async (ch) => {
+            if (embed) {
+                const sentMsg = await ch.send({ embeds: [embed] });
+                trackBotMessage(sentMsg.id, {
+                    sessionKey: 'cron:notification',
+                    userMessage: '(scheduled notification)',
+                    botResponse: text.slice(0, 500),
+                });
+            }
+            else {
+                const chunks = chunkText(text, 1900);
+                let sentCount = 0;
+                for (const chunk of chunks) {
+                    const sentMsg = await ch.send(chunk);
+                    trackBotMessage(sentMsg.id, {
+                        sessionKey: 'cron:notification',
+                        userMessage: '(scheduled notification)',
+                        botResponse: chunk.slice(0, 500),
+                    });
+                    sentCount++;
+                }
+                return sentCount;
+            }
+            return 1;
+        };
+        try {
+            await sendContent(channel);
+        }
+        catch (err) {
+            // Channel might be stale — clear cache, wait briefly, retry once
+            cachedDmChannel = null;
+            logger.warn({ err }, 'Discord notification failed — retrying once');
+            try {
+                await new Promise(r => setTimeout(r, 2000));
+                const user = await client.users.fetch(DISCORD_OWNER_ID, { force: true });
+                channel = await user.createDM();
+                cachedDmChannel = channel;
+                await sendContent(channel);
+            }
+            catch (retryErr) {
+                logger.error({ err: retryErr }, 'Discord notification retry failed');
+                throw retryErr;
+            }
+        }
+    }
+    // Register sender only after Discord client is ready
+    client.once(Events.ClientReady, () => {
+        dispatcher.register('discord', discordNotify);
+    });
+    logger.info('Starting Discord bot...');
+    await client.login(DISCORD_TOKEN);
+}
+// ── Plan orchestration helper ─────────────────────────────────────────
+async function handlePlanCommand(gateway, sessionKey, taskDescription, channel) {
+    const streamer = new DiscordStreamingMessage(channel);
+    await streamer.start();
+    await streamer.update('Planning...');
+    let progressTimer = null;
+    try {
+        const result = await gateway.handlePlan(sessionKey, taskDescription, async (updates) => {
+            // Build progress display (truncate descriptions to fit Discord limit)
+            const lines = [
+                `**Plan:** ${taskDescription.slice(0, 100)}`,
+                '',
+                ...updates.map((u, i) => {
+                    const num = `[${i + 1}/${updates.length}]`;
+                    const desc = u.description.slice(0, 60);
+                    switch (u.status) {
+                        case 'done': return `${num} ${desc} \u2713 (${Math.round((u.durationMs ?? 0) / 1000)}s)`;
+                        case 'running': return `${num} ${desc} \u23f3 running...`;
+                        case 'failed': return `${num} ${desc} \u2717 failed`;
+                        default: return `${num} ${desc} \u25cb waiting`;
+                    }
+                }),
+            ];
+            await streamer.update(lines.join('\n').slice(0, 1800));
+            // Start progress timer on first running step
+            if (!progressTimer && updates.some(u => u.status === 'running')) {
+                progressTimer = setInterval(async () => {
+                    // Re-render with live elapsed times (static snapshot — no orchestrator ref needed)
+                    await streamer.update(lines.join('\n').slice(0, 1800));
+                }, 5000);
+            }
+        }, 
+        // Approval gate — show plan and wait for user confirmation
+        async (_planSummary, steps) => {
+            // Show plan preview as a new message (previous streamer may be finalized from a revision round)
+            const planPreview = `**Plan:** ${taskDescription.slice(0, 100)}\n\n` +
+                steps.map((s, i) => `${i + 1}. **${s.id}** — ${s.description.slice(0, 60)}`).join('\n');
+            if ('send' in channel) {
+                await sendChunked(channel, planPreview);
+            }
+            // Send approval buttons
+            const requestId = `plan-${Date.now()}`;
+            await sendApprovalButtons(channel, 'Approve this plan?', 'plan', requestId, { showRevise: true });
+            // Wait for the user to click approve/deny/revise
+            const approvalResult = await gateway.requestApproval('Pending approval', requestId);
+            if (typeof approvalResult === 'string') {
+                // Revision — post status and return feedback so orchestrator re-generates
+                if ('send' in channel) {
+                    await channel.send(`\u2728 *Revising plan...*`);
+                }
+                return approvalResult;
+            }
+            if (approvalResult) {
+                // Start a new streamer for execution progress
+                const newStreamer = new DiscordStreamingMessage(channel);
+                await newStreamer.start();
+                await newStreamer.update('Executing plan...');
+                // Swap the streamer reference for progress updates
+                Object.assign(streamer, {
+                    message: newStreamer.message,
+                    lastEdit: newStreamer.lastEdit,
+                    pendingText: '',
+                    lastFlushedText: '',
+                    isFinal: false,
+                });
+            }
+            return approvalResult;
+        });
+        await streamer.finalize(result);
+    }
+    catch (err) {
+        logger.error({ err }, 'Plan execution failed');
+        await streamer.finalize(`Plan failed: ${err}`);
+    }
+    finally {
+        if (progressTimer)
+            clearInterval(progressTimer);
+    }
+}
+//# sourceMappingURL=discord.js.map