skimpyclaw 0.3.14 → 0.4.0

package/dist/channels/discord/handlers.js

@@ -1,8 +1,8 @@
-import { ActionRowBuilder, ButtonBuilder, ButtonStyle, AttachmentBuilder, } from 'discord.js';
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, AttachmentBuilder, ChannelType, } from 'discord.js';
 import { join } from 'path';
 import { tmpdir } from 'os';
 import { existsSync, mkdirSync, writeFileSync, unlinkSync } from 'fs';
-import { getCurrentModel, setCurrentModel } from '../../gateway.js';
+import { getCurrentModel, getCurrentThinking, setCurrentModel, setCurrentThinking } from '../../gateway.js';
 import { getCronJobs, runCronJob } from '../../cron.js';
 import { runAgentTurn } from '../../agent.js';
 import { runHeartbeatCheck } from '../../heartbeat.js';
@@ -13,14 +13,554 @@ import { transcribeAudio, synthesizeSpeech } from '../../voice.js';
 import * as sessions from '../../sessions.js';
 import { formatAliases, formatModelSelectionError, getModelSelectionUsage, resolveModelSelection } from '../../model-selection.js';
 import { KNOWN_COMMANDS } from './types.js';
-import { getHistory, addToHistory, clearHistory, replaceHistory, getDiscordToolConfig, getDiscordRunContext, conversationKey, buildHelpText, sendLongText, startTypingIndicator, } from './utils.js';
+import { getHistory, addToHistory, clearHistory, replaceHistory, getDiscordToolConfig, getDiscordRunContext, conversationKey, buildCodeAgentThreadContext, buildHelpText, sendLongText, sendLongTextToChannel, startTypingIndicator, startTypingIndicatorForChannel, } from './utils.js';
+import { createTaskThread, buildThreadUrl } from './threads.js';
+import { bindThreadAgent, getAgentProfileByAlias, getThreadAgentByThreadId, listAgentProfiles, parseDiscordAgentMention, removeAgentProfile, setAgentProfileModel, setAgentProfilePrompt, setAgentProfileThinking, upsertAgentProfile, } from './thread-agents.js';
+import { isDocumentAttachment, processAttachments, supportedExtensions } from './attachments.js';
+import { getSession, linkThread } from '../../code-agents/interactive-sessions.js';
+import { handleInteractiveThreadMessage } from '../../code-agents/interactive-resume.js';
 // ── Command handler ─────────────────────────────────────────────────
+const THREAD_AGENT_USAGE = [
+    'Usage:',
+    '/agent create <alias> [agent-id]',
+    '/agent use <alias> [message]',
+    '/agent model [alias] <model-alias|provider/model|model-id>',
+    '/agent effort [alias] <none|low|medium|high|xhigh>',
+    '/agent prompt [alias] <prompt text>',
+    '/agent delete <alias>',
+    '/agent list',
+    '@alias <message>',
+].join('\n');
+const THINKING_LEVELS = ['none', 'low', 'medium', 'high', 'xhigh'];
+const AGENT_PROMPT_MAX_CHARS = 20_000;
+function parseThinkingLevel(value) {
+    const normalized = (value || '').trim().toLowerCase().replace(/^x[-_ ]?high$/, 'xhigh');
+    if (normalized === 'off')
+        return 'none';
+    return THINKING_LEVELS.includes(normalized) ? normalized : null;
+}
+function formatThinkingUsage(command = '/effort') {
+    return `Usage: ${command} <${THINKING_LEVELS.join('|')}>`;
+}
+function formatAgentIds(config) {
+    return Object.keys(config.agents.list).join(', ') || '(none configured)';
+}
+function resolveConfiguredAgentId(config, rawAgentId) {
+    const candidate = (rawAgentId || config.agents.default).trim();
+    return config.agents.list[candidate] ? candidate : null;
+}
+function formatThreadAgent(record) {
+    const prompt = record.promptOverlay
+        ? `\nPrompt: ${record.promptOverlay.length > 120 ? record.promptOverlay.slice(0, 120) + '...' : record.promptOverlay}`
+        : '';
+    const model = record.model ? `, model ${record.model}` : '';
+    const thinking = record.thinking ? `, effort ${record.thinking}` : '';
+    return `This thread uses @${record.alias} -> ${record.agentId}${model}${thinking}${prompt}`;
+}
+function formatAgentProfile(profile) {
+    const prompt = profile.promptOverlay
+        ? `\nPrompt: ${profile.promptOverlay.length > 120 ? profile.promptOverlay.slice(0, 120) + '...' : profile.promptOverlay}`
+        : '';
+    const model = profile.model ? `, model ${profile.model}` : '';
+    const thinking = profile.thinking ? `, effort ${profile.thinking}` : '';
+    return `@${profile.alias} -> ${profile.agentId}${model}${thinking}${prompt}`;
+}
+function formatThreadAgentThreadName(alias, taskText) {
+    const task = (taskText || '')
+        .replace(/https?:\/\/\S+\/pull\/(\d+)\S*/g, '#$1')
+        .replace(/https?:\/\/\S+\/issues\/(\d+)\S*/g, '#$1')
+        .replace(/https?:\/\/\S+/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+    const base = task || 'agent';
+    const maxTaskLength = Math.max(10, 96 - alias.length);
+    const suffix = base.length > maxTaskLength ? `${base.slice(0, maxTaskLength - 3).trim()}...` : base;
+    return `${alias}: ${suffix}`.slice(0, 100);
+}
+function isDiscordThreadChannel(channel) {
+    if (channel.isDMBased())
+        return false;
+    if (channel.isThread())
+        return true;
+    const channelType = channel.type;
+    return channelType === ChannelType.PublicThread
+        || channelType === ChannelType.PrivateThread
+        || channelType === ChannelType.AnnouncementThread;
+}
+async function createThreadAgentThread(message, alias, taskText) {
+    if (message.channel.isDMBased())
+        return null;
+    if (!('threads' in message.channel))
+        return null;
+    try {
+        const thread = await message.startThread({
+            name: formatThreadAgentThreadName(alias, taskText),
+            autoArchiveDuration: 1440,
+        });
+        return thread;
+    }
+    catch (err) {
+        console.error('[discord-thread-agents] Failed to create thread agent thread:', err);
+        return null;
+    }
+}
+function getThreadAgentForMessage(message, config) {
+    if (!isDiscordThreadChannel(message.channel))
+        return null;
+    const record = getThreadAgentByThreadId(message.channel.id);
+    if (!record)
+        return null;
+    if (!config.agents.list[record.agentId])
+        return null;
+    return record;
+}
+function profileAsThreadAgent(profile, message, channel) {
+    const channelId = isThreadChannel(channel)
+        ? channel.parentId ?? message.channelId
+        : message.channelId;
+    return {
+        ...profile,
+        threadId: channel.id,
+        profileAlias: profile.alias,
+        guildId: message.guildId || undefined,
+        channelId,
+    };
+}
+function isDMBasedChannel(channel) {
+    return Boolean(channel.isDMBased?.());
+}
+function isThreadChannel(channel) {
+    return Boolean(channel.isThread?.());
+}
+function conversationKeyForChannel(message, channel) {
+    if (isDMBasedChannel(channel)) {
+        return `dm:${message.author.id}`;
+    }
+    return `channel:${channel.id}`;
+}
+function sendableChannel(channel) {
+    return channel;
+}
+function getDiscordRunContextForChannel(message, channel) {
+    const context = getDiscordRunContext(message);
+    const isDm = isDMBasedChannel(channel);
+    const isThread = !isDm && isThreadChannel(channel);
+    return {
+        ...context,
+        sessionId: channel.id,
+        metadata: {
+            ...(context.metadata || {}),
+            isDm,
+            ...(isThread ? {
+                discordThreadId: channel.id,
+                discordChannelId: channel.parentId ?? message.channelId,
+            } : {}),
+        },
+    };
+}
+function getThreadAgentRunContext(message, threadAgent, channel = message.channel) {
+    const context = getDiscordRunContextForChannel(message, channel);
+    if (!threadAgent) {
+        return {
+            ...context,
+            metadata: {
+                ...(context.metadata || {}),
+                thinkingOverride: getCurrentThinking(),
+            },
+        };
+    }
+    return {
+        ...context,
+        metadata: {
+            ...(context.metadata || {}),
+            threadAgentAlias: threadAgent.alias,
+            threadAgentId: threadAgent.agentId,
+            threadAgentModel: threadAgent.model,
+            threadAgentThinking: threadAgent.thinking,
+            thinkingOverride: threadAgent.thinking ?? getCurrentThinking(),
+            threadAgentPromptOverlay: threadAgent.promptOverlay,
+        },
+    };
+}
+async function runThreadAgentPrompt(message, targetChannel, threadAgent, promptText, config, options = {}) {
+    const prompt = promptText.trim();
+    if (!prompt)
+        return;
+    if (options.announceTask) {
+        await sendLongTextToChannel(sendableChannel(targetChannel), `Task from @${message.author.username || message.author.id}:\n${prompt}`);
+    }
+    const stopTyping = startTypingIndicatorForChannel(targetChannel);
+    try {
+        const key = conversationKeyForChannel(message, targetChannel);
+        const history = await getHistory(key);
+        const response = await runAgentTurn(threadAgent.agentId, prompt, config, threadAgent.model || getCurrentModel(), getDiscordToolConfig(config), history, getThreadAgentRunContext(message, threadAgent, targetChannel));
+        await addToHistory(key, prompt, response);
+        await sendLongTextToChannel(sendableChannel(targetChannel), response);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : 'Unknown error';
+        await sendLongTextToChannel(sendableChannel(targetChannel), `Error: ${msg}`);
+    }
+    finally {
+        stopTyping();
+    }
+}
+async function runMentionedAgentPrompt(message, text, config) {
+    const invocation = parseDiscordAgentMention(text);
+    if (!invocation)
+        return false;
+    const profile = getAgentProfileByAlias(invocation.alias);
+    if (!profile) {
+        await message.reply(`No Discord agent profile found for @${invocation.alias}. Create it with /agent create ${invocation.alias}.`);
+        return true;
+    }
+    if (!config.agents.list[profile.agentId]) {
+        await message.reply(`Agent profile @${profile.alias} points to missing configured agent "${profile.agentId}".`);
+        return true;
+    }
+    if (!invocation.prompt) {
+        await message.reply(`Usage: @${profile.alias} <message>`);
+        return true;
+    }
+    try {
+        if (message.channel.isDMBased()) {
+            const record = profileAsThreadAgent(profile, message, message.channel);
+            await runThreadAgentPrompt(message, message.channel, record, invocation.prompt, config);
+            return true;
+        }
+        const isThread = isDiscordThreadChannel(message.channel);
+        const targetChannel = isThread
+            ? message.channel
+            : await createThreadAgentThread(message, profile.alias, invocation.prompt);
+        if (!targetChannel) {
+            await message.reply('Agent mentions can only run in a DM, inside a Discord thread, or from a channel where I can create one.');
+            return true;
+        }
+        const record = bindThreadAgent({
+            threadId: targetChannel.id,
+            alias: profile.alias,
+            createdBy: message.author.id,
+            guildId: message.guildId,
+            channelId: targetChannel.isThread() ? targetChannel.parentId ?? message.channelId : message.channelId,
+        });
+        if (!isThread) {
+            const url = buildThreadUrl(message.guildId, targetChannel.id);
+            await message.reply(url ? `Started @${profile.alias}: ${url}` : `Started @${profile.alias}.`);
+        }
+        await runThreadAgentPrompt(message, targetChannel, record, invocation.prompt, config, {
+            announceTask: !isThread,
+        });
+        return true;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        await message.reply(`Error: ${msg}`);
+        return true;
+    }
+}
+async function readPromptAttachment(message) {
+    const docAttachments = message.attachments.filter(a => isDocumentAttachment(a));
+    if (docAttachments.size === 0)
+        return {};
+    const results = await processAttachments([...docAttachments.values()]);
+    const firstOk = results.find(result => result.ok && result.text?.trim());
+    if (firstOk?.text) {
+        return {
+            text: firstOk.text.trim(),
+            filename: firstOk.filename,
+        };
+    }
+    const errors = results.map(result => result.error).filter(Boolean);
+    return {
+        error: errors.join('\n') || `Could not read attached prompt. Supported file types: ${supportedExtensions().map(e => `.${e}`).join(', ')}`,
+    };
+}
+function normalizeAliasArg(value) {
+    return (value || '').trim().replace(/^@/, '').toLowerCase();
+}
+function getAgentProfileCommandTarget(message, alias) {
+    const normalizedAlias = normalizeAliasArg(alias);
+    if (normalizedAlias) {
+        const profile = getAgentProfileByAlias(normalizedAlias);
+        return profile ? { profile } : { profile: null, error: `No Discord agent profile found for @${normalizedAlias}.` };
+    }
+    if (isDiscordThreadChannel(message.channel)) {
+        const record = getThreadAgentByThreadId(message.channel.id);
+        if (record)
+            return { profile: getAgentProfileByAlias(record.alias), record };
+    }
+    const profiles = listAgentProfiles();
+    if (profiles.length === 1)
+        return { profile: profiles[0] };
+    return {
+        profile: null,
+        error: `No target agent profile found. Pass an alias. Known profiles: ${profiles.map(profile => `@${profile.alias}`).join(', ') || '(none)'}.`,
+    };
+}
+function getOrCreateAgentProfileCommandTarget(message, config, alias) {
+    const normalizedAlias = normalizeAliasArg(alias);
+    if (!normalizedAlias)
+        return getAgentProfileCommandTarget(message);
+    const existing = getAgentProfileByAlias(normalizedAlias);
+    if (existing)
+        return { profile: existing };
+    try {
+        return {
+            profile: upsertAgentProfile({
+                alias: normalizedAlias,
+                agentId: config.agents.default,
+                createdBy: message.author.id,
+            }),
+            created: true,
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { profile: null, error: msg };
+    }
+}
+async function handleEffortCommand(message, args) {
+    if (!args[0]) {
+        await message.reply(`Current effort: ${getCurrentThinking() || 'default'}\n${formatThinkingUsage()}`);
+        return;
+    }
+    const next = parseThinkingLevel(args[0]);
+    if (!next) {
+        await message.reply(`Invalid effort: ${args[0]}\n${formatThinkingUsage()}`);
+        return;
+    }
+    setCurrentThinking(next);
+    await message.reply(`Effort set to: ${next}`);
+}
+async function handleThreadAgentCommand(message, args, config) {
+    const subcommand = (args[0] || 'show').toLowerCase();
+    if (subcommand === 'list') {
+        const profiles = listAgentProfiles();
+        if (profiles.length === 0) {
+            await message.reply('No Discord agent profiles configured.');
+            return;
+        }
+        const profileText = profiles.map(formatAgentProfile).join('\n\n');
+        await sendLongText(message, `Profiles:\n${profileText}`);
+        return;
+    }
+    const isThread = isDiscordThreadChannel(message.channel);
+    if (subcommand === 'show' || subcommand === 'status') {
+        if (!isThread) {
+            await message.reply(THREAD_AGENT_USAGE);
+            return;
+        }
+        const record = getThreadAgentByThreadId(message.channel.id);
+        await message.reply(record ? formatThreadAgent(record) : `No agent profile is active in this thread.\n\n${THREAD_AGENT_USAGE}`);
+        return;
+    }
+    if (subcommand === 'create') {
+        const alias = args[1];
+        const agentId = resolveConfiguredAgentId(config, args[2]);
+        if (!alias || !agentId) {
+            await message.reply(`Usage: /agent create <alias> [agent-id]\nConfigured agents: ${formatAgentIds(config)}`);
+            return;
+        }
+        try {
+            const profile = upsertAgentProfile({
+                alias,
+                agentId,
+                createdBy: message.author.id,
+            });
+            await message.reply(`Configured agent profile ${formatAgentProfile(profile)}`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            await message.reply(`Error: ${msg}`);
+        }
+        return;
+    }
+    if (subcommand === 'use') {
+        const alias = args[1];
+        const profile = getAgentProfileByAlias(alias);
+        if (!alias || !profile) {
+            await message.reply(`Usage: /agent use <alias> [message]\nKnown profiles: ${listAgentProfiles().map(p => p.alias).join(', ') || '(none)'}`);
+            return;
+        }
+        const initialPrompt = args.slice(2).join(' ').trim();
+        try {
+            const targetChannel = isThread
+                ? message.channel
+                : await createThreadAgentThread(message, profile.alias, initialPrompt);
+            if (!targetChannel) {
+                await message.reply('Agent profiles can only run in a Discord thread or from a channel where I can create one.');
+                return;
+            }
+            const record = bindThreadAgent({
+                threadId: targetChannel.id,
+                alias: profile.alias,
+                createdBy: message.author.id,
+                guildId: message.guildId,
+                channelId: targetChannel.isThread() ? targetChannel.parentId ?? message.channelId : message.channelId,
+            });
+            const url = buildThreadUrl(message.guildId, targetChannel.id);
+            await message.reply(!isThread && url
+                ? `Started @${profile.alias}: ${url}`
+                : `This thread now uses ${formatAgentProfile(profile)}`);
+            if (initialPrompt) {
+                await runThreadAgentPrompt(message, targetChannel, record, initialPrompt, config, {
+                    announceTask: !isThread,
+                });
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            await message.reply(`Error: ${msg}`);
+        }
+        return;
+    }
+    if (subcommand === 'prompt') {
+        let alias;
+        let promptStart = 1;
+        const attachmentPrompt = await readPromptAttachment(message);
+        if (attachmentPrompt.error) {
+            await message.reply(attachmentPrompt.error);
+            return;
+        }
+        if (args[1]) {
+            const candidateAlias = normalizeAliasArg(args[1]);
+            if ((attachmentPrompt.text && args.length === 2) || (args.length > 2 && getAgentProfileByAlias(candidateAlias))) {
+                alias = args[1];
+                promptStart = 2;
+            }
+        }
+        const inlinePrompt = args.slice(promptStart).join(' ').trim();
+        const prompt = attachmentPrompt.text || inlinePrompt;
+        if (!prompt) {
+            await message.reply('Usage: /agent prompt [@alias] <prompt text>\nYou can also attach a .txt or .md file.');
+            return;
+        }
+        if (prompt.length > AGENT_PROMPT_MAX_CHARS) {
+            await message.reply(`Prompt is too long. Keep agent prompts under ${AGENT_PROMPT_MAX_CHARS.toLocaleString()} characters.`);
+            return;
+        }
+        const target = getAgentProfileCommandTarget(message, alias);
+        if (!target.profile) {
+            await message.reply(`${target.error || 'No target agent profile found.'}\n\n${THREAD_AGENT_USAGE}`);
+            return;
+        }
+        const profile = setAgentProfilePrompt(target.profile.alias, prompt);
+        if (!profile)
+            return;
+        const source = attachmentPrompt.filename ? ` from ${attachmentPrompt.filename}` : '';
+        await message.reply(`Updated prompt for @${profile.alias}${source}.`);
+        return;
+    }
+    if (subcommand === 'model') {
+        let alias;
+        let modelStart = 1;
+        if (args[1] && args.length > 2) {
+            alias = args[1];
+            modelStart = 2;
+        }
+        const modelInput = args.slice(modelStart).join(' ').trim();
+        if (!modelInput) {
+            await message.reply(`Usage: /agent model [agent-alias] <model-alias|provider/model|model-id>\nAvailable model aliases: ${formatAliases(config)}`);
+            return;
+        }
+        const selection = resolveModelSelection(modelInput, config);
+        if (!selection.ok || !selection.resolved) {
+            await message.reply(formatModelSelectionError(selection.error || 'Invalid model selection', config));
+            return;
+        }
+        const target = getOrCreateAgentProfileCommandTarget(message, config, alias);
+        if (!target.profile) {
+            await message.reply(`${target.error || 'No target agent profile found.'}\n\n${THREAD_AGENT_USAGE}`);
+            return;
+        }
+        const profile = setAgentProfileModel(target.profile.alias, selection.resolved);
+        if (!profile)
+            return;
+        const aliasText = selection.aliasUsed ? ` (${selection.aliasUsed})` : '';
+        const createdText = target.created ? `Created agent profile @${profile.alias} -> ${profile.agentId}\n` : '';
+        await message.reply(`${createdText}Updated model for @${profile.alias}: ${selection.resolved}${aliasText}`);
+        return;
+    }
+    if (subcommand === 'think' || subcommand === 'effort') {
+        let alias;
+        let effortArg = args[1];
+        if (args[1] && args.length > 2) {
+            alias = args[1];
+            effortArg = args[2];
+        }
+        const next = parseThinkingLevel(effortArg);
+        if (!effortArg || !next) {
+            await message.reply(`Usage: /agent ${subcommand} [agent-alias] <${THINKING_LEVELS.join('|')}>`);
+            return;
+        }
+        const target = getOrCreateAgentProfileCommandTarget(message, config, alias);
+        if (!target.profile) {
+            await message.reply(`${target.error || 'No target agent profile found.'}\n\n${THREAD_AGENT_USAGE}`);
+            return;
+        }
+        const profile = setAgentProfileThinking(target.profile.alias, next);
+        if (!profile)
+            return;
+        const createdText = target.created ? `Created agent profile @${profile.alias} -> ${profile.agentId}\n` : '';
+        await message.reply(`${createdText}Updated effort for @${profile.alias}: ${next}`);
+        return;
+    }
+    if (subcommand === 'clear-model') {
+        const target = getAgentProfileCommandTarget(message, args[1]);
+        if (!target.profile) {
+            await message.reply(target.error || 'No target agent profile found.');
+            return;
+        }
+        const profile = setAgentProfileModel(target.profile.alias, undefined);
+        await message.reply(profile ? `Cleared model override for @${profile.alias}.` : 'No target agent profile found.');
+        return;
+    }
+    if (subcommand === 'clear-think' || subcommand === 'clear-effort') {
+        const target = getAgentProfileCommandTarget(message, args[1]);
+        if (!target.profile) {
+            await message.reply(target.error || 'No target agent profile found.');
+            return;
+        }
+        const profile = setAgentProfileThinking(target.profile.alias, undefined);
+        await message.reply(profile ? `Cleared effort override for @${profile.alias}.` : 'No target agent profile found.');
+        return;
+    }
+    if (subcommand === 'clear-prompt') {
+        const target = getAgentProfileCommandTarget(message, args[1]);
+        if (!target.profile) {
+            await message.reply(target.error || 'No target agent profile found.');
+            return;
+        }
+        const profile = setAgentProfilePrompt(target.profile.alias, undefined);
+        await message.reply(profile ? `Cleared prompt for @${profile.alias}.` : 'No target agent profile found.');
+        return;
+    }
+    if (subcommand === 'delete') {
+        const alias = args[1];
+        if (!alias) {
+            await message.reply('Usage: /agent delete <alias>');
+            return;
+        }
+        const removed = removeAgentProfile(alias);
+        await message.reply(removed ? `Deleted agent profile @${normalizeAliasArg(alias)} and its thread bindings.` : `No Discord agent profile found for @${normalizeAliasArg(alias)}.`);
+        return;
+    }
+    await message.reply(THREAD_AGENT_USAGE);
+}
 export async function handleCommand(message, command, args, config, silenceUntil, setSilenceUntil) {
     const rawArgs = args.join(' ').trim();
     if (command === 'start' || command === 'help') {
         await sendLongText(message, buildHelpText(config));
         return;
     }
+    if (command === 'agent') {
+        await handleThreadAgentCommand(message, args, config);
+        return;
+    }
+    if (command === 'effort' || command === 'think') {
+        await handleEffortCommand(message, args);
+        return;
+    }
     if (command === 'model') {
         if (!rawArgs) {
             const current = getCurrentModel();
@@ -45,6 +585,7 @@ export async function handleCommand(message, command, args, config, silenceUntil
     }
     if (command === 'status') {
         const model = getCurrentModel();
+        const effort = getCurrentThinking();
         const { getLastMessage } = await import('../../gateway.js');
         const last = getLastMessage();
         const jobs = getCronJobs();
@@ -77,6 +618,7 @@ export async function handleCommand(message, command, args, config, silenceUntil
         }
         await message.reply(`Agent: ${config.agents.default}\n` +
             `Model: ${model}\n` +
+            `Effort: ${effort || 'default'}\n` +
             `Last message: ${last?.toLocaleString() || 'never'}\n` +
             `Silence until: ${silenceUntil?.toLocaleString() || 'not silenced'}\n\n` +
             `${caLine}\n\n` +
@@ -267,6 +809,35 @@ export async function handleIncomingMessage(message, config) {
         await message.reply('Too many messages. Please wait a moment.');
         return;
     }
+    // Interactive coding session intercept: if this is a thread bound to an active
+    // interactive session, route the message to --resume instead of the main agent.
+    if (message.channel.isThread()) {
+        try {
+            const session = getSession(message.channel.id);
+            if (session) {
+                const stopTyping = startTypingIndicator(message);
+                try {
+                    await handleInteractiveThreadMessage({
+                        discordThreadId: message.channel.id,
+                        userMessage: message.content,
+                        postToThread: async (chunks) => {
+                            for (const c of chunks) {
+                                await message.channel.send(c);
+                            }
+                        },
+                    });
+                }
+                finally {
+                    stopTyping();
+                }
+                return;
+            }
+        }
+        catch (err) {
+            console.error('[discord] Interactive-session intercept failed:', err);
+            // fall through to normal handling
+        }
+    }
     // Check for image attachments
     const imageAttachments = message.attachments.filter(a => a.contentType?.startsWith('image/'));
     if (imageAttachments.size > 0) {
@@ -294,7 +865,8 @@ export async function handleIncomingMessage(message, config) {
             ];
             const key = conversationKey(message);
             const history = await getHistory(key);
-            const response = await runAgentTurn(config.agents.default, content, config, getCurrentModel(), getDiscordToolConfig(config), history, getDiscordRunContext(message));
+            const threadAgent = getThreadAgentForMessage(message, config);
+            const response = await runAgentTurn(threadAgent?.agentId || config.agents.default, content, config, threadAgent?.model || getCurrentModel(), getDiscordToolConfig(config), history, getThreadAgentRunContext(message, threadAgent));
             await addToHistory(key, `[Image: ${caption}]`, response);
             await sendLongText(message, response);
         }
@@ -307,6 +879,53 @@ export async function handleIncomingMessage(message, config) {
         }
         return;
     }
+    // Check for document attachments (txt, pdf, etc.)
+    const docAttachments = message.attachments.filter(a => isDocumentAttachment(a));
+    if (docAttachments.size > 0) {
+        const stopTyping = startTypingIndicator(message);
+        try {
+            const results = await processAttachments([...docAttachments.values()]);
+            const extracted = [];
+            const errors = [];
+            for (const r of results) {
+                if (r.ok && r.text) {
+                    extracted.push(`--- ${r.filename} ---\n${r.text}`);
+                }
+                else if (r.error) {
+                    errors.push(r.error);
+                }
+            }
+            if (errors.length > 0 && extracted.length === 0) {
+                // All attachments failed
+                const supported = supportedExtensions().map(e => `.${e}`).join(', ');
+                await message.reply(errors.join('\n') + `\n\nSupported file types: ${supported}`);
+                return;
+            }
+            // Build context: extracted text + user's message (or default prompt)
+            const userText = message.content.trim() || 'Please read and summarize the attached file(s).';
+            const attachmentContext = extracted.join('\n\n');
+            const prompt = `The user uploaded the following file(s):\n\n${attachmentContext}\n\n${userText}`;
+            // Include any errors as a note
+            const errorNote = errors.length > 0
+                ? `\n\n(Note: some attachments could not be processed: ${errors.join('; ')})`
+                : '';
+            const key = conversationKey(message);
+            const history = await getHistory(key);
+            const threadAgent = getThreadAgentForMessage(message, config);
+            const response = await runAgentTurn(threadAgent?.agentId || config.agents.default, prompt + errorNote, config, threadAgent?.model || getCurrentModel(), getDiscordToolConfig(config), history, getThreadAgentRunContext(message, threadAgent));
+            const filenames = results.map(r => r.filename).join(', ');
+            await addToHistory(key, `[Attachments: ${filenames}] ${userText}`, response);
+            await sendLongText(message, response);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : 'Unknown error';
+            await message.reply(`Error processing attachment(s): ${msg}`);
+        }
+        finally {
+            stopTyping();
+        }
+        return;
+    }
     // Check for voice message attachments
     const voiceAttachments = message.attachments.filter(a => a.contentType?.startsWith('audio/') || a.contentType?.startsWith('voice/'));
     if (voiceAttachments.size > 0) {
@@ -335,7 +954,8 @@ export async function handleIncomingMessage(message, config) {
                 }
                 const key = conversationKey(message);
                 const history = await getHistory(key);
-                const agentResponse = await runAgentTurn(config.agents.default, transcription, config, getCurrentModel(), getDiscordToolConfig(config), history, getDiscordRunContext(message));
+                const threadAgent = getThreadAgentForMessage(message, config);
+                const agentResponse = await runAgentTurn(threadAgent?.agentId || config.agents.default, transcription, config, threadAgent?.model || getCurrentModel(), getDiscordToolConfig(config), history, getThreadAgentRunContext(message, threadAgent));
                 await addToHistory(key, transcription, agentResponse);
                 console.log('[discord] TTS check - sendVoice:', config.voice?.channels?.['discord']?.sendVoice);
                 if (config.voice?.channels?.['discord']?.sendVoice) {
@@ -343,7 +963,7 @@ export async function handleIncomingMessage(message, config) {
                     try {
                         const speech = await synthesizeSpeech(agentResponse, config.voice);
                         console.log('[discord] TTS synthesis success:', speech.format, speech.provider, 'buffer size:', speech.buffer.length);
-                        const voiceAttachment = new AttachmentBuilder(speech.buffer, {
+                        const voiceAttachment = new AttachmentBuilder(Buffer.from(speech.buffer), {
                             name: `voice-reply.${speech.format}`,
                             description: 'Voice reply'
                         });
@@ -376,6 +996,9 @@ export async function handleIncomingMessage(message, config) {
     const text = message.content.trim();
     if (!text)
         return;
+    if (await runMentionedAgentPrompt(message, text, config)) {
+        return;
+    }
     const isPrefixedCommand = text.startsWith('/') || text.startsWith('!');
     const isDm = message.channel.isDMBased();
     if (isPrefixedCommand || isDm) {
@@ -398,9 +1021,73 @@ export async function handleIncomingMessage(message, config) {
     const stopTyping = startTypingIndicator(message);
     try {
         const history = await getHistory(key);
-        const response = await runAgentTurn(config.agents.default, text, config, getCurrentModel(), getDiscordToolConfig(config), history, getDiscordRunContext(message));
+        const threadAgent = getThreadAgentForMessage(message, config);
+        const codeAgentContext = buildCodeAgentThreadContext(message);
+        const prompt = codeAgentContext
+            ? `${codeAgentContext}\n\nUser message in this Discord thread:\n${text}`
+            : text;
+        const response = await runAgentTurn(threadAgent?.agentId || config.agents.default, prompt, config, threadAgent?.model || getCurrentModel(), getDiscordToolConfig(config), history, getThreadAgentRunContext(message, threadAgent));
         await addToHistory(key, text, response);
         await sendLongText(message, response);
+        // If the response started coding agent(s), create threads for status updates.
+        // Only consider tasks started within the current turn (last 2 min) — older
+        // unthreaded tasks are stale registry entries that will steal the single
+        // thread Discord allows per message.
+        const useThreads = config.channels.discord?.threadedReplies !== false;
+        if (useThreads && !message.channel.isDMBased()) {
+            try {
+                const { getUnthreadedTasksForChat, writeCodeAgentTask } = await import('../../code-agents/registry.js');
+                const chatId = Number(message.channel.id);
+                const freshnessCutoffMs = Date.now() - 2 * 60 * 1000;
+                const unthreadedTasks = getUnthreadedTasksForChat(chatId).filter(t => {
+                    const started = Date.parse(t.startedAt);
+                    return Number.isFinite(started) && started >= freshnessCutoffMs;
+                });
+                const isThread = message.channel.isThread();
+                for (const task of unthreadedTasks) {
+                    let assignedThreadId;
+                    if (isThread) {
+                        // Already in a thread — use it directly instead of creating a sub-thread
+                        task.discordThreadId = message.channel.id;
+                        task.discordChannelId = message.channel.parentId ?? message.channelId;
+                        writeCodeAgentTask(task);
+                        assignedThreadId = task.discordThreadId;
+                    }
+                    else {
+                        const taskPreview = task.task.length > 90 ? task.task.slice(0, 90) + '...' : task.task;
+                        const threadId = await createTaskThread(message, task.id, taskPreview);
+                        if (threadId) {
+                            task.discordThreadId = threadId;
+                            task.discordChannelId = message.channelId;
+                            writeCodeAgentTask(task);
+                            assignedThreadId = threadId;
+                            // Post a clickable link to the new thread for easy mobile access.
+                            const url = buildThreadUrl(message.guildId, threadId);
+                            if (url) {
+                                try {
+                                    await message.channel.send(`→ ${task.interactive ? 'Interactive session' : 'Thread'} ${task.id}: ${url}`);
+                                }
+                                catch (err) {
+                                    console.warn(`[discord] Failed to post thread link for ${task.id}:`, err);
+                                }
+                            }
+                        }
+                    }
+                    // Promote any pending interactive session from taskId-keyed to threadId-keyed.
+                    if (assignedThreadId && task.interactive) {
+                        try {
+                            linkThread(task.id, assignedThreadId);
+                        }
+                        catch (err) {
+                            console.error(`[discord] Failed to link interactive session ${task.id} → ${assignedThreadId}:`, err);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                console.error(`[discord] Failed to create threads for spawned tasks:`, err);
+            }
+        }
     }
     catch (error) {
         const msg = error instanceof Error ? error.message : 'Unknown error';