kimaki 0.4.86 → 0.4.88

package/dist/agent-model.e2e.test.js

@@ -345,7 +345,8 @@ describe('agent model resolution', () => {
         Reply with exactly: system-context-check
         --- from: assistant (TestBot)
         ⬥ system-context-ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
+        ⬥ ok"
       `);
     }, 15_000);
     test('new thread uses channel model when channel model preference is set', async () => {
@@ -512,6 +513,7 @@ describe('agent model resolution', () => {
         Reply with exactly: second-thread-msg
         --- from: assistant (TestBot)
         ⬥ ok
+        ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
       `);
         const secondMessages = await discord.thread(thread.id).getMessages();
@@ -594,6 +596,7 @@ describe('agent model resolution', () => {
         Reply with exactly: default-second-msg
         --- from: assistant (TestBot)
         ⬥ ok
+        ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         const secondMessages = await discord.thread(thread.id).getMessages();
@@ -661,6 +664,7 @@ describe('agent model resolution', () => {
         Reply with exactly: after-switch-msg
         --- from: assistant (TestBot)
         ⬥ ok
+        ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
       `);
         const secondFooter = [...(await discord.thread(thread.id).getMessages())]

package/dist/cli-send-thread.e2e.test.js

@@ -0,0 +1,280 @@
+// E2e test for `kimaki send --channel` flow.
+// Reproduces the race condition where the bot's MessageCreate GuildText handler
+// tries to call startThread() on the same message that the CLI already created
+// a thread for via REST, causing DiscordAPIError[160004].
+//
+// The test simulates the exact flow: bot posts a starter message with a
+// `start: true` embed marker, then creates a thread on that message via REST.
+// The ThreadCreate handler should pick it up and start a session. The
+// MessageCreate handler must NOT try to startThread() on the same message.
+//
+// Uses opencode-deterministic-provider (no real LLM calls).
+// Poll timeouts: 4s max, 100ms interval.
+import fs from 'node:fs';
+import path from 'node:path';
+import url from 'node:url';
+import { describe, beforeAll, afterAll, test, expect } from 'vitest';
+import { ChannelType, Client, GatewayIntentBits, Partials, Routes, } from 'discord.js';
+import { DigitalDiscord } from 'discord-digital-twin/src';
+import { buildDeterministicOpencodeConfig, } from 'opencode-deterministic-provider';
+import { setDataDir } from './config.js';
+import { store } from './store.js';
+import { startDiscordBot } from './discord-bot.js';
+import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChannelVerbosity, } from './database.js';
+import { startHranaServer, stopHranaServer } from './hrana-server.js';
+import { initializeOpencodeForDirectory, stopOpencodeServer, } from './opencode.js';
+import { chooseLockPort, cleanupTestSessions, waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
+import yaml from 'js-yaml';
+const TEST_USER_ID = '200000000000000830';
+const TEXT_CHANNEL_ID = '200000000000000831';
+const BOT_USER_ID = '200000000000000832';
+function createRunDirectories() {
+    const root = path.resolve(process.cwd(), 'tmp', 'cli-send-thread-e2e');
+    fs.mkdirSync(root, { recursive: true });
+    const dataDir = fs.mkdtempSync(path.join(root, 'data-'));
+    const projectDirectory = path.join(root, 'project');
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    return { root, dataDir, projectDirectory };
+}
+function createDiscordJsClient({ restUrl }) {
+    return new Client({
+        intents: [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.GuildMessages,
+            GatewayIntentBits.MessageContent,
+            GatewayIntentBits.GuildVoiceStates,
+        ],
+        partials: [
+            Partials.Channel,
+            Partials.Message,
+            Partials.User,
+            Partials.ThreadMember,
+        ],
+        rest: {
+            api: restUrl,
+            version: '10',
+        },
+    });
+}
+function createDeterministicMatchers() {
+    const userReplyMatcher = {
+        id: 'user-reply',
+        priority: 10,
+        when: {
+            lastMessageRole: 'user',
+            latestUserTextIncludes: 'Reply with exactly:',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'default-reply' },
+                { type: 'text-delta', id: 'default-reply', delta: 'ok' },
+                { type: 'text-end', id: 'default-reply' },
+                {
+                    type: 'finish',
+                    finishReason: 'stop',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+            partDelaysMs: [0, 100, 0, 0, 0],
+        },
+    };
+    return [userReplyMatcher];
+}
+describe('kimaki send --channel thread creation', () => {
+    let directories;
+    let discord;
+    let botClient;
+    let previousDefaultVerbosity = null;
+    let testStartTime = Date.now();
+    beforeAll(async () => {
+        testStartTime = Date.now();
+        directories = createRunDirectories();
+        const lockPort = chooseLockPort({ key: TEXT_CHANNEL_ID });
+        process.env['KIMAKI_LOCK_PORT'] = String(lockPort);
+        setDataDir(directories.dataDir);
+        previousDefaultVerbosity = store.getState().defaultVerbosity;
+        store.setState({ defaultVerbosity: 'tools_and_text' });
+        const digitalDiscordDbPath = path.join(directories.dataDir, 'digital-discord.db');
+        discord = new DigitalDiscord({
+            botUser: { id: BOT_USER_ID },
+            guild: {
+                name: 'CLI Send E2E Guild',
+                // Use bot as guild owner so bot-authored messages pass
+                // hasKimakiBotPermission (owner check). This matches production where
+                // the bot typically has admin or is the app owner. Without this, the
+                // MessageCreate handler drops bot messages before reaching the GuildText
+                // path, hiding the race condition we're testing.
+                ownerId: BOT_USER_ID,
+            },
+            channels: [
+                {
+                    id: TEXT_CHANNEL_ID,
+                    name: 'cli-send-e2e',
+                    type: ChannelType.GuildText,
+                },
+            ],
+            users: [
+                {
+                    id: TEST_USER_ID,
+                    username: 'cli-send-tester',
+                },
+            ],
+            dbUrl: `file:${digitalDiscordDbPath}`,
+        });
+        await discord.start();
+        const providerNpm = url
+            .pathToFileURL(path.resolve(process.cwd(), '..', 'opencode-deterministic-provider', 'src', 'index.ts'))
+            .toString();
+        const opencodeConfig = buildDeterministicOpencodeConfig({
+            providerName: 'deterministic-provider',
+            providerNpm,
+            model: 'deterministic-v2',
+            smallModel: 'deterministic-v2',
+            settings: {
+                strict: false,
+                matchers: createDeterministicMatchers(),
+            },
+        });
+        fs.writeFileSync(path.join(directories.projectDirectory, 'opencode.json'), JSON.stringify(opencodeConfig, null, 2));
+        const dbPath = path.join(directories.dataDir, 'discord-sessions.db');
+        const hranaResult = await startHranaServer({ dbPath });
+        if (hranaResult instanceof Error) {
+            throw hranaResult;
+        }
+        process.env['KIMAKI_DB_URL'] = hranaResult;
+        await initDatabase();
+        await setBotToken(discord.botUserId, discord.botToken);
+        await setChannelDirectory({
+            channelId: TEXT_CHANNEL_ID,
+            directory: directories.projectDirectory,
+            channelType: 'text',
+        });
+        await setChannelVerbosity(TEXT_CHANNEL_ID, 'tools_and_text');
+        botClient = createDiscordJsClient({ restUrl: discord.restUrl });
+        await startDiscordBot({
+            token: discord.botToken,
+            appId: discord.botUserId,
+            discordClient: botClient,
+        });
+        // Pre-warm the opencode server
+        const warmup = await initializeOpencodeForDirectory(directories.projectDirectory);
+        if (warmup instanceof Error) {
+            throw warmup;
+        }
+    }, 60_000);
+    afterAll(async () => {
+        if (directories) {
+            await cleanupTestSessions({
+                projectDirectory: directories.projectDirectory,
+                testStartTime,
+            });
+        }
+        if (botClient) {
+            botClient.destroy();
+        }
+        await stopOpencodeServer();
+        await Promise.all([
+            closeDatabase().catch(() => {
+                return;
+            }),
+            stopHranaServer().catch(() => {
+                return;
+            }),
+            discord?.stop().catch(() => {
+                return;
+            }),
+        ]);
+        delete process.env['KIMAKI_LOCK_PORT'];
+        delete process.env['KIMAKI_DB_URL'];
+        if (previousDefaultVerbosity) {
+            store.setState({ defaultVerbosity: previousDefaultVerbosity });
+        }
+        if (directories) {
+            fs.rmSync(directories.dataDir, { recursive: true, force: true });
+        }
+    }, 10_000);
+    test('bot-posted starter message with start marker creates thread without DiscordAPIError[160004]', async () => {
+        // Simulate what `kimaki send --channel` does:
+        // 1. Bot posts a starter message with `start: true` embed marker
+        // 2. Bot creates a thread on that message via REST
+        // The ThreadCreate handler should pick it up. The MessageCreate GuildText
+        // handler must NOT try to startThread() on the same message (race).
+        const prompt = 'Reply with exactly: cli-send-test';
+        const embedMarker = {
+            start: true,
+            username: 'cli-send-tester',
+            userId: TEST_USER_ID,
+        };
+        // Step 1: Bot posts the starter message (same as CLI's sendDiscordMessageWithOptionalAttachment)
+        const starterMessage = (await botClient.rest.post(Routes.channelMessages(TEXT_CHANNEL_ID), {
+            body: {
+                content: prompt,
+                embeds: [
+                    { color: 0x2b2d31, footer: { text: yaml.dump(embedMarker) } },
+                ],
+            },
+        }));
+        // Give the bot's MessageCreate handler time to process the starter
+        // message. Without the fix, the handler enters the GuildText path and
+        // tries to startThread() on this message, which races the CLI's thread
+        // creation below. The digital twin enforces Discord's 160004 uniqueness
+        // constraint, so the second startThread call fails.
+        await new Promise((resolve) => {
+            setTimeout(resolve, 200);
+        });
+        // Verify the MessageCreate handler did NOT create a thread on this
+        // message. If the handler ignored the start marker (correct behavior),
+        // no thread exists yet and the REST call below succeeds.
+        const threadsBeforeCliCreate = await discord
+            .channel(TEXT_CHANNEL_ID)
+            .getThreads();
+        const preExistingThread = threadsBeforeCliCreate.find((t) => {
+            return t.name?.includes('cli-send-test');
+        });
+        // This is the core regression assertion: without the fix in discord-bot.ts
+        // (skipping start markers in the GuildText handler), the MessageCreate
+        // handler would create a thread here, and the CLI's REST call below would
+        // fail with 160004.
+        expect(preExistingThread).toBeUndefined();
+        // Step 2: Bot creates a thread on the starter message (same as CLI's Routes.threads call)
+        const threadData = (await botClient.rest.post(Routes.threads(TEXT_CHANNEL_ID, starterMessage.id), {
+            body: {
+                name: 'cli-send-test',
+                auto_archive_duration: 1440,
+            },
+        }));
+        // Add test user to thread
+        await botClient.rest.put(Routes.threadMembers(threadData.id, TEST_USER_ID));
+        // Wait for the bot to reply with the ⬥ prefix (proves ThreadCreate
+        // handler picked up the starter message and started a session)
+        await waitForBotMessageContaining({
+            discord,
+            threadId: threadData.id,
+            userId: discord.botUserId,
+            text: '⬥',
+            timeout: 4_000,
+        });
+        // Wait for footer message (proves session completed successfully)
+        await waitForFooterMessage({
+            discord,
+            threadId: threadData.id,
+            timeout: 4_000,
+            afterMessageIncludes: '⬥',
+            afterAuthorId: discord.botUserId,
+        });
+        // Verify no DiscordAPIError[160004] or other errors in the thread.
+        // Before the fix, the MessageCreate GuildText handler would race the
+        // CLI's thread creation and produce an error message here.
+        const messages = await discord.thread(threadData.id).getMessages();
+        const errorMessages = messages.filter((m) => {
+            return m.content.includes('Error:') || m.content.includes('160004');
+        });
+        expect(errorMessages).toHaveLength(0);
+        // Verify at least one ⬥ reply exists (session produced output)
+        const botReplies = messages.filter((m) => {
+            return (m.author.id === discord.botUserId && m.content.startsWith('⬥'));
+        });
+        expect(botReplies.length).toBeGreaterThanOrEqual(1);
+    }, 15_000);
+});

package/dist/commands/btw.js

@@ -0,0 +1,111 @@
+// /btw command - Fork the current session with full context and send a new prompt.
+// Unlike /fork, this does not replay past messages in Discord. It just creates
+// a new thread, forks the entire session (no messageID), and immediately
+// dispatches the user's prompt so the forked session starts working right away.
+import { ChannelType, ThreadAutoArchiveDuration, MessageFlags, } from 'discord.js';
+import { getThreadSession, setThreadSession } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveWorkingDirectory, resolveTextChannel, sendThreadMessage, } from '../discord-utils.js';
+import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.FORK);
+export async function handleBtwCommand({ command, appId, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await command.reply({
+            content: 'This command can only be used in a thread with an active session',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const prompt = command.options.getString('prompt', true);
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const { projectDirectory } = resolved;
+    const sessionId = await getThreadSession(channel.id);
+    if (!sessionId) {
+        await command.reply({
+            content: 'No active session in this thread',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    await command.deferReply({ flags: MessageFlags.Ephemeral });
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        await command.editReply({
+            content: `Failed to fork session: ${getClient.message}`,
+        });
+        return;
+    }
+    try {
+        // Fork the entire session (no messageID = fork at the latest point)
+        const forkResponse = await getClient().session.fork({
+            sessionID: sessionId,
+        });
+        if (!forkResponse.data) {
+            await command.editReply('Failed to fork session');
+            return;
+        }
+        const forkedSession = forkResponse.data;
+        const textChannel = await resolveTextChannel(channel);
+        if (!textChannel) {
+            await command.editReply('Could not resolve parent text channel');
+            return;
+        }
+        const threadName = `btw: ${prompt}`.slice(0, 100);
+        const thread = await textChannel.threads.create({
+            name: threadName,
+            autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+            reason: `btw fork from session ${sessionId}`,
+        });
+        // Claim the forked session immediately so external polling does not race
+        await setThreadSession(thread.id, forkedSession.id);
+        await thread.members.add(command.user.id);
+        logger.log(`Created btw fork session ${forkedSession.id} in thread ${thread.id} from ${sessionId}`);
+        // Short status message with prompt instead of replaying past messages
+        const sourceThreadLink = `<#${channel.id}>`;
+        await sendThreadMessage(thread, `Reusing context from ${sourceThreadLink} to answer prompt...\n${prompt}`);
+        // Create runtime and dispatch the prompt immediately
+        const runtime = getOrCreateRuntime({
+            threadId: thread.id,
+            thread,
+            projectDirectory,
+            sdkDirectory: projectDirectory,
+            channelId: textChannel.id,
+            appId,
+        });
+        await runtime.enqueueIncoming({
+            prompt,
+            userId: command.user.id,
+            username: command.user.displayName,
+            appId,
+            mode: 'opencode',
+        });
+        await command.editReply(`Session forked! Continue in ${thread.toString()}`);
+    }
+    catch (error) {
+        logger.error('Error in /btw:', error);
+        await command.editReply(`Failed to fork session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/discord-bot.js

@@ -512,6 +512,15 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 }
             }
             if (channel.type === ChannelType.GuildText) {
+                // `kimaki send` posts a starter message with a `start` embed marker,
+                // then creates the thread via REST. The ThreadCreate handler picks up
+                // that thread and starts the session. If we don't skip here, this
+                // handler races the CLI to call startThread() on the same message,
+                // causing DiscordAPIError[160004] "A thread has already been created
+                // for this message".
+                if (promptMarker?.start) {
+                    return;
+                }
                 const textChannel = channel;
                 voiceLogger.log(`[GUILD_TEXT] Message in text channel #${textChannel.name} (${textChannel.id})`);
                 const channelConfig = await getChannelDirectory(textChannel.id);

package/dist/discord-command-registration.js

@@ -161,11 +161,6 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
         })
             .setDMPermission(false)
             .toJSON(),
-        new SlashCommandBuilder()
-            .setName('toggle-mention-mode')
-            .setDescription(truncateCommandDescription('Toggle mention-only mode (bot only responds when @mentioned)'))
-            .setDMPermission(false)
-            .toJSON(),
         new SlashCommandBuilder()
             .setName('add-project')
             .setDescription(truncateCommandDescription('Create Discord channels for a project. Use `npx kimaki project add` for unlisted projects'))
@@ -214,11 +209,6 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .setDescription(truncateCommandDescription('Compact the session context by summarizing conversation history'))
             .setDMPermission(false)
             .toJSON(),
-        new SlashCommandBuilder()
-            .setName('stop')
-            .setDescription(truncateCommandDescription('Abort the current OpenCode request in this thread'))
-            .setDMPermission(false)
-            .toJSON(),
         new SlashCommandBuilder()
             .setName('share')
             .setDescription(truncateCommandDescription('Share the current session as a public URL'))
@@ -234,6 +224,18 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .setDescription(truncateCommandDescription('Fork the session from a past user message'))
             .setDMPermission(false)
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('btw')
+            .setDescription(truncateCommandDescription('Ask something without polluting or blocking the current session'))
+            .addStringOption((option) => {
+            option
+                .setName('prompt')
+                .setDescription(truncateCommandDescription('The message to send in the forked session'))
+                .setRequired(true);
+            return option;
+        })
+            .setDMPermission(false)
+            .toJSON(),
         new SlashCommandBuilder()
             .setName('model')
             .setDescription(truncateCommandDescription('Set the preferred model for this channel or session'))
@@ -338,11 +340,6 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .setDescription(truncateCommandDescription('Show current session ID and opencode attach command for this thread'))
             .setDMPermission(false)
             .toJSON(),
-        new SlashCommandBuilder()
-            .setName('memory-snapshot')
-            .setDescription(truncateCommandDescription('Write a V8 heap snapshot to disk for memory debugging'))
-            .setDMPermission(false)
-            .toJSON(),
         new SlashCommandBuilder()
             .setName('upgrade-and-restart')
             .setDescription(truncateCommandDescription('Upgrade kimaki to the latest version and restart the bot'))
@@ -369,10 +366,43 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .setDMPermission(false)
             .toJSON(),
     ];
-    // Add user-defined commands with source-based suffixes (-cmd / -skill)
+    // Dynamic commands are registered in priority order: agents → user commands → skills → MCP prompts.
+    // This ordering matters because we slice to MAX_DISCORD_COMMANDS (100) at the end,
+    // so lower-priority dynamic commands get trimmed first if the total exceeds the limit.
+    // 1. Agent-specific quick commands like /plan-agent, /build-agent
+    // Filter to primary/all mode agents (same as /agent command shows), excluding hidden agents
+    const primaryAgents = agents.filter((a) => (a.mode === 'primary' || a.mode === 'all') && !a.hidden);
+    for (const agent of primaryAgents) {
+        const sanitizedName = sanitizeAgentName(agent.name);
+        // Skip if sanitized name is empty or would create invalid command name
+        // Discord command names must start with a lowercase letter or number
+        if (!sanitizedName || !/^[a-z0-9]/.test(sanitizedName)) {
+            continue;
+        }
+        // Truncate base name before appending suffix so the -agent suffix is never
+        // lost to Discord's 32-char command name limit.
+        const agentSuffix = '-agent';
+        const agentBaseName = sanitizedName.slice(0, 32 - agentSuffix.length);
+        const commandName = `${agentBaseName}${agentSuffix}`;
+        const description = buildQuickAgentCommandDescription({
+            agentName: agent.name,
+            description: agent.description,
+        });
+        commands.push(new SlashCommandBuilder()
+            .setName(commandName)
+            .setDescription(truncateCommandDescription(description))
+            .setDMPermission(false)
+            .toJSON());
+    }
+    // 2. User-defined commands, skills, and MCP prompts (ordered by priority)
     // Also populate registeredUserCommands in the store for /queue-command autocomplete
     const newRegisteredCommands = [];
-    for (const cmd of userCommands) {
+    // Sort: regular commands first, then skills, then MCP prompts
+    const sourceOrder = { config: 0, skill: 1, mcp: 2 };
+    const sortedUserCommands = [...userCommands].sort((a, b) => {
+        return (sourceOrder[a.source || ''] ?? 0) - (sourceOrder[b.source || ''] ?? 0);
+    });
+    for (const cmd of sortedUserCommands) {
         if (SKIP_USER_COMMANDS.includes(cmd.name)) {
             continue;
         }
@@ -415,30 +445,12 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .toJSON());
     }
     store.setState({ registeredUserCommands: newRegisteredCommands });
-    // Add agent-specific quick commands like /plan-agent, /build-agent
-    // Filter to primary/all mode agents (same as /agent command shows), excluding hidden agents
-    const primaryAgents = agents.filter((a) => (a.mode === 'primary' || a.mode === 'all') && !a.hidden);
-    for (const agent of primaryAgents) {
-        const sanitizedName = sanitizeAgentName(agent.name);
-        // Skip if sanitized name is empty or would create invalid command name
-        // Discord command names must start with a lowercase letter or number
-        if (!sanitizedName || !/^[a-z0-9]/.test(sanitizedName)) {
-            continue;
-        }
-        // Truncate base name before appending suffix so the -agent suffix is never
-        // lost to Discord's 32-char command name limit.
-        const agentSuffix = '-agent';
-        const agentBaseName = sanitizedName.slice(0, 32 - agentSuffix.length);
-        const commandName = `${agentBaseName}${agentSuffix}`;
-        const description = buildQuickAgentCommandDescription({
-            agentName: agent.name,
-            description: agent.description,
-        });
-        commands.push(new SlashCommandBuilder()
-            .setName(commandName)
-            .setDescription(truncateCommandDescription(description))
-            .setDMPermission(false)
-            .toJSON());
+    // Discord allows max 100 guild commands. Slice to stay within the limit,
+    // trimming lowest-priority dynamic commands (MCP prompts, then skills) first.
+    const MAX_DISCORD_COMMANDS = 100;
+    if (commands.length > MAX_DISCORD_COMMANDS) {
+        cliLogger.warn(`COMMANDS: ${commands.length} commands exceed Discord limit of ${MAX_DISCORD_COMMANDS}, truncating to ${MAX_DISCORD_COMMANDS}`);
+        commands.length = MAX_DISCORD_COMMANDS;
     }
     const rest = createDiscordRest(token);
     const uniqueGuildIds = Array.from(new Set(guildIds.filter((guildId) => guildId)));

package/dist/gateway-proxy.e2e.test.js

@@ -353,8 +353,9 @@ describeIf('gateway-proxy e2e', () => {
         --- from: user (proxy-tester)
         follow up through proxy
         --- from: assistant (TestBot)
-        ⬥ gateway-proxy-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ ok"
       `);
         expect(reply).toBeDefined();
         expect(reply.content.trim().length).toBeGreaterThan(0);
@@ -384,8 +385,9 @@ describeIf('gateway-proxy e2e', () => {
         --- from: user (proxy-tester)
         follow up through proxy
         --- from: assistant (TestBot)
-        ⬥ gateway-proxy-reply
+        ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ ok
         --- from: user (proxy-tester)
         !echo proxy-shell-test
         --- from: assistant (TestBot)

package/dist/interaction-handler.js

@@ -8,7 +8,6 @@ import { handleMergeWorktreeCommand, handleMergeWorktreeAutocomplete, } from './
 import { handleToggleWorktreesCommand } from './commands/worktree-settings.js';
 import { handleWorktreesCommand } from './commands/worktrees.js';
 import { handleTasksCommand } from './commands/tasks.js';
-import { handleToggleMentionModeCommand } from './commands/mention-mode.js';
 import { handleResumeCommand, handleResumeAutocomplete, } from './commands/resume.js';
 import { handleAddProjectCommand, handleAddProjectAutocomplete, } from './commands/add-project.js';
 import { handleRemoveProjectCommand, handleRemoveProjectAutocomplete, } from './commands/remove-project.js';
@@ -19,6 +18,7 @@ import { handleCompactCommand } from './commands/compact.js';
 import { handleShareCommand } from './commands/share.js';
 import { handleDiffCommand } from './commands/diff.js';
 import { handleForkCommand, handleForkSelectMenu } from './commands/fork.js';
+import { handleBtwCommand } from './commands/btw.js';
 import { handleModelCommand, handleProviderSelectMenu, handleModelSelectMenu, handleModelScopeSelectMenu, } from './commands/model.js';
 import { handleUnsetModelCommand } from './commands/unset-model.js';
 import { handleLoginCommand, handleLoginSelect, handleLoginTextButton, handleLoginTextModalSubmit, handleLoginApiKeyButton, handleOAuthCodeButton, handleOAuthCodeModalSubmit, handleApiKeyModalSubmit, } from './commands/login.js';
@@ -36,7 +36,6 @@ import { handleRestartOpencodeServerCommand } from './commands/restart-opencode-
 import { handleRunCommand } from './commands/run-command.js';
 import { handleContextUsageCommand } from './commands/context-usage.js';
 import { handleSessionIdCommand } from './commands/session-id.js';
-import { handleMemorySnapshotCommand } from './commands/memory-snapshot.js';
 import { handleUpgradeAndRestartCommand } from './commands/upgrade.js';
 import { handleMcpCommand, handleMcpSelectMenu } from './commands/mcp.js';
 import { handleScreenshareCommand, handleScreenshareStopCommand, } from './commands/screenshare.js';
@@ -120,12 +119,6 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                             appId,
                         });
                         return;
-                    case 'toggle-mention-mode':
-                        await handleToggleMentionModeCommand({
-                            command: interaction,
-                            appId,
-                        });
-                        return;
                     case 'resume':
                         await handleResumeCommand({ command: interaction, appId });
                         return;
@@ -142,7 +135,6 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                         });
                         return;
                     case 'abort':
-                    case 'stop':
                         await handleAbortCommand({ command: interaction, appId });
                         return;
                     case 'compact':
@@ -157,6 +149,9 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     case 'fork':
                         await handleForkCommand(interaction);
                         return;
+                    case 'btw':
+                        await handleBtwCommand({ command: interaction, appId });
+                        return;
                     case 'model':
                         await handleModelCommand({ interaction, appId });
                         return;
@@ -205,12 +200,6 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     case 'session-id':
                         await handleSessionIdCommand({ command: interaction, appId });
                         return;
-                    case 'memory-snapshot':
-                        await handleMemorySnapshotCommand({
-                            command: interaction,
-                            appId,
-                        });
-                        return;
                     case 'upgrade-and-restart':
                         await handleUpgradeAndRestartCommand({
                             command: interaction,