kimaki 0.4.29 → 0.4.31

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kimaki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cli.js

@@ -13,6 +13,7 @@ import { createLogger } from './logger.js';
 import { spawn, spawnSync, execSync } from 'node:child_process';
 import http from 'node:http';
 import { setDataDir, getDataDir, getLockPort } from './config.js';
+import { extractTagsArrays } from './xml.js';
 const cliLogger = createLogger('CLI');
 const cli = cac('kimaki');
 process.title = 'kimaki';
@@ -387,7 +388,12 @@ async function run({ restart, addChannels }) {
         }
     }
     const s = spinner();
-    s.start('Creating Discord client and connecting...');
+    // Start OpenCode server EARLY - let it initialize in parallel with Discord login.
+    // This is the biggest startup bottleneck (can take 1-30 seconds to spawn and wait for ready)
+    const currentDir = process.cwd();
+    s.start('Starting OpenCode server...');
+    const opencodePromise = initializeOpencodeForDirectory(currentDir);
+    s.message('Connecting to Discord...');
     const discordClient = await createDiscordClient();
     const guilds = [];
     const kimakiChannels = [];
@@ -396,11 +402,43 @@ async function run({ restart, addChannels }) {
         await new Promise((resolve, reject) => {
             discordClient.once(Events.ClientReady, async (c) => {
                 guilds.push(...Array.from(c.guilds.cache.values()));
-                for (const guild of guilds) {
+                // Process all guilds in parallel for faster startup
+                const guildResults = await Promise.all(guilds.map(async (guild) => {
+                    // Create Kimaki role if it doesn't exist, or fix its position (fire-and-forget)
+                    guild.roles
+                        .fetch()
+                        .then(async (roles) => {
+                        const existingRole = roles.find((role) => role.name.toLowerCase() === 'kimaki');
+                        if (existingRole) {
+                            // Move to bottom if not already there
+                            if (existingRole.position > 1) {
+                                await existingRole.setPosition(1);
+                                cliLogger.info(`Moved "Kimaki" role to bottom in ${guild.name}`);
+                            }
+                            return;
+                        }
+                        return guild.roles.create({
+                            name: 'Kimaki',
+                            position: 1, // Place at bottom so anyone with Manage Roles can assign it
+                            reason: 'Kimaki bot permission role - assign to users who can start sessions, send messages in threads, and use voice features',
+                        });
+                    })
+                        .then((role) => {
+                        if (role) {
+                            cliLogger.info(`Created "Kimaki" role in ${guild.name}`);
+                        }
+                    })
+                        .catch((error) => {
+                        cliLogger.warn(`Could not create Kimaki role in ${guild.name}: ${error instanceof Error ? error.message : String(error)}`);
+                    });
                     const channels = await getChannelsWithDescriptions(guild);
                     const kimakiChans = channels.filter((ch) => ch.kimakiDirectory && (!ch.kimakiApp || ch.kimakiApp === appId));
-                    if (kimakiChans.length > 0) {
-                        kimakiChannels.push({ guild, channels: kimakiChans });
+                    return { guild, channels: kimakiChans };
+                }));
+                // Collect results
+                for (const result of guildResults) {
+                    if (result.channels.length > 0) {
+                        kimakiChannels.push(result);
                     }
                 }
                 resolve(null);
@@ -440,26 +478,22 @@ async function run({ restart, addChannels }) {
             .join('\n');
         note(channelList, 'Existing Kimaki Channels');
     }
-    s.start('Starting OpenCode server...');
-    const currentDir = process.cwd();
-    let getClient = await initializeOpencodeForDirectory(currentDir);
-    s.stop('OpenCode server started!');
-    s.start('Fetching OpenCode projects...');
-    let projects = [];
-    try {
-        const projectsResponse = await getClient().project.list({});
-        if (!projectsResponse.data) {
-            throw new Error('Failed to fetch projects');
-        }
-        projects = projectsResponse.data;
-        s.stop(`Found ${projects.length} OpenCode project(s)`);
-    }
-    catch (error) {
-        s.stop('Failed to fetch projects');
-        cliLogger.error('Error:', error instanceof Error ? error.message : String(error));
-        discordClient.destroy();
-        process.exit(EXIT_NO_RESTART);
-    }
+    // Await the OpenCode server that was started in parallel with Discord login
+    s.start('Waiting for OpenCode server...');
+    const getClient = await opencodePromise;
+    s.stop('OpenCode server ready!');
+    s.start('Fetching OpenCode data...');
+    // Fetch projects and commands in parallel
+    const [projects, allUserCommands] = await Promise.all([
+        getClient().project.list({}).then((r) => r.data || []).catch((error) => {
+            s.stop('Failed to fetch projects');
+            cliLogger.error('Error:', error instanceof Error ? error.message : String(error));
+            discordClient.destroy();
+            process.exit(EXIT_NO_RESTART);
+        }),
+        getClient().command.list({ query: { directory: currentDir } }).then((r) => r.data || []).catch(() => []),
+    ]);
+    s.stop(`Found ${projects.length} OpenCode project(s)`);
     const existingDirs = kimakiChannels.flatMap(({ channels }) => channels
         .filter((ch) => ch.kimakiDirectory && ch.kimakiApp === appId)
         .map((ch) => ch.kimakiDirectory)
@@ -540,19 +574,6 @@ async function run({ restart, addChannels }) {
             }
         }
     }
-    // Fetch user-defined commands using the already-running server
-    const allUserCommands = [];
-    try {
-        const commandsResponse = await getClient().command.list({
-            query: { directory: currentDir },
-        });
-        if (commandsResponse.data) {
-            allUserCommands.push(...commandsResponse.data);
-        }
-    }
-    catch {
-        // Ignore errors fetching commands
-    }
     // Log available user commands
     const registrableCommands = allUserCommands.filter((cmd) => !SKIP_USER_COMMANDS.includes(cmd.name));
     if (registrableCommands.length > 0) {
@@ -597,6 +618,7 @@ cli
     .option('--restart', 'Prompt for new credentials even if saved')
     .option('--add-channels', 'Select OpenCode projects to create Discord channels before starting')
     .option('--data-dir <path>', 'Data directory for config and database (default: ~/.kimaki)')
+    .option('--install-url', 'Print the bot install URL and exit')
     .action(async (options) => {
     try {
         // Set data directory early, before any database access
@@ -604,6 +626,18 @@ cli
             setDataDir(options.dataDir);
             cliLogger.log(`Using data directory: ${getDataDir()}`);
         }
+        if (options.installUrl) {
+            const db = getDatabase();
+            const existingBot = db
+                .prepare('SELECT app_id FROM bot_tokens ORDER BY created_at DESC LIMIT 1')
+                .get();
+            if (!existingBot) {
+                cliLogger.error('No bot configured yet. Run `kimaki` first to set up.');
+                process.exit(EXIT_NO_RESTART);
+            }
+            console.log(generateBotInstallUrl({ clientId: existingBot.app_id }));
+            process.exit(0);
+        }
         await checkSingleInstance();
         await startLockServer();
         await run({
@@ -683,5 +717,149 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
 });
+// Magic prefix used to identify bot-initiated sessions.
+// The running bot will recognize this prefix and start a session.
+const BOT_SESSION_PREFIX = '🤖 **Bot-initiated session**';
+cli
+    .command('start-session', 'Start a new session in a Discord channel (creates thread, bot handles the rest)')
+    .option('-c, --channel <channelId>', 'Discord channel ID')
+    .option('-p, --prompt <prompt>', 'Initial prompt for the session')
+    .option('-n, --name [name]', 'Thread name (optional, defaults to prompt preview)')
+    .option('-a, --app-id [appId]', 'Bot application ID (required if no local database)')
+    .action(async (options) => {
+    try {
+        const { channel: channelId, prompt, name, appId: optionAppId } = options;
+        if (!channelId) {
+            cliLogger.error('Channel ID is required. Use --channel <channelId>');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (!prompt) {
+            cliLogger.error('Prompt is required. Use --prompt <prompt>');
+            process.exit(EXIT_NO_RESTART);
+        }
+        // Get bot token from env var or database
+        const envToken = process.env.KIMAKI_BOT_TOKEN;
+        let botToken;
+        let appId = optionAppId;
+        if (envToken) {
+            botToken = envToken;
+            if (!appId) {
+                // Try to get app_id from database if available (optional in CI)
+                try {
+                    const db = getDatabase();
+                    const botRow = db
+                        .prepare('SELECT app_id FROM bot_tokens ORDER BY created_at DESC LIMIT 1')
+                        .get();
+                    appId = botRow?.app_id;
+                }
+                catch {
+                    // Database might not exist in CI, that's ok
+                }
+            }
+        }
+        else {
+            // Fall back to database
+            try {
+                const db = getDatabase();
+                const botRow = db
+                    .prepare('SELECT app_id, token FROM bot_tokens ORDER BY created_at DESC LIMIT 1')
+                    .get();
+                if (botRow) {
+                    botToken = botRow.token;
+                    appId = appId || botRow.app_id;
+                }
+            }
+            catch (e) {
+                // Database error - will fall through to the check below
+                cliLogger.error('Database error:', e instanceof Error ? e.message : String(e));
+            }
+        }
+        if (!botToken) {
+            cliLogger.error('No bot token found. Set KIMAKI_BOT_TOKEN env var or run `kimaki` first to set up.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const s = spinner();
+        s.start('Fetching channel info...');
+        // Get channel info to extract directory from topic
+        const channelResponse = await fetch(`https://discord.com/api/v10/channels/${channelId}`, {
+            headers: {
+                'Authorization': `Bot ${botToken}`,
+            },
+        });
+        if (!channelResponse.ok) {
+            const error = await channelResponse.text();
+            s.stop('Failed to fetch channel');
+            throw new Error(`Discord API error: ${channelResponse.status} - ${error}`);
+        }
+        const channelData = await channelResponse.json();
+        if (!channelData.topic) {
+            s.stop('Channel has no topic');
+            throw new Error(`Channel #${channelData.name} has no topic. It must have a <kimaki.directory> tag.`);
+        }
+        const extracted = extractTagsArrays({
+            xml: channelData.topic,
+            tags: ['kimaki.directory', 'kimaki.app'],
+        });
+        const projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
+        const channelAppId = extracted['kimaki.app']?.[0]?.trim();
+        if (!projectDirectory) {
+            s.stop('No kimaki.directory tag found');
+            throw new Error(`Channel #${channelData.name} has no <kimaki.directory> tag in topic.`);
+        }
+        // Verify app ID matches if both are present
+        if (channelAppId && appId && channelAppId !== appId) {
+            s.stop('Channel belongs to different bot');
+            throw new Error(`Channel belongs to a different bot (expected: ${appId}, got: ${channelAppId})`);
+        }
+        s.message('Creating starter message...');
+        // Create starter message with magic prefix
+        // The full prompt goes in the message so the bot can read it
+        const starterMessageResponse = await fetch(`https://discord.com/api/v10/channels/${channelId}/messages`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bot ${botToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                content: `${BOT_SESSION_PREFIX}\n${prompt}`,
+            }),
+        });
+        if (!starterMessageResponse.ok) {
+            const error = await starterMessageResponse.text();
+            s.stop('Failed to create message');
+            throw new Error(`Discord API error: ${starterMessageResponse.status} - ${error}`);
+        }
+        const starterMessage = await starterMessageResponse.json();
+        s.message('Creating thread...');
+        // Create thread from the message
+        const threadName = name || (prompt.length > 80 ? prompt.slice(0, 77) + '...' : prompt);
+        const threadResponse = await fetch(`https://discord.com/api/v10/channels/${channelId}/messages/${starterMessage.id}/threads`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bot ${botToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                name: threadName.slice(0, 100),
+                auto_archive_duration: 1440, // 1 day
+            }),
+        });
+        if (!threadResponse.ok) {
+            const error = await threadResponse.text();
+            s.stop('Failed to create thread');
+            throw new Error(`Discord API error: ${threadResponse.status} - ${error}`);
+        }
+        const threadData = await threadResponse.json();
+        s.stop('Thread created!');
+        const threadUrl = `https://discord.com/channels/${channelData.guild_id}/${threadData.id}`;
+        note(`Thread: ${threadData.name}\nDirectory: ${projectDirectory}\n\nThe running bot will pick this up and start the session.\n\nURL: ${threadUrl}`, '✅ Thread Created');
+        console.log(threadUrl);
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.message : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
 cli.help();
 cli.parse();

package/dist/commands/ask-question.js

@@ -4,7 +4,7 @@
 import { StringSelectMenuBuilder, StringSelectMenuInteraction, ActionRowBuilder, } from 'discord.js';
 import crypto from 'node:crypto';
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js';
-import { getOpencodeServerPort } from '../opencode.js';
+import { getOpencodeClientV2 } from '../opencode.js';
 import { createLogger } from '../logger.js';
 const logger = createLogger('ASK_QUESTION');
 // Store pending question contexts by hash
@@ -128,25 +128,18 @@ export async function handleAskQuestionSelectMenu(interaction) {
  */
 async function submitQuestionAnswers(context) {
     try {
+        const clientV2 = getOpencodeClientV2(context.directory);
+        if (!clientV2) {
+            throw new Error('OpenCode server not found for directory');
+        }
         // Build answers array: each element is an array of selected labels for that question
-        const answersPayload = context.questions.map((_, i) => {
+        const answers = context.questions.map((_, i) => {
             return context.answers[i] || [];
         });
-        // Reply to the question using direct HTTP call to OpenCode API
-        // (v1 SDK doesn't have question.reply, so we call it directly)
-        const port = getOpencodeServerPort(context.directory);
-        if (!port) {
-            throw new Error('OpenCode server not found for directory');
-        }
-        const response = await fetch(`http://127.0.0.1:${port}/question/${context.requestId}/reply`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ answers: answersPayload }),
+        await clientV2.question.reply({
+            requestID: context.requestId,
+            answers,
         });
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`Failed to reply to question: ${response.status} ${text}`);
-        }
         logger.log(`Submitted answers for question ${context.requestId} in session ${context.sessionId}`);
     }
     catch (error) {
@@ -182,3 +175,43 @@ export function parseAskUserQuestionTool(part) {
     }
     return input;
 }
+/**
+ * Cancel a pending question for a thread (e.g., when user sends a new message).
+ * Sends cancellation response to OpenCode so the session can continue.
+ */
+export async function cancelPendingQuestion(threadId) {
+    // Find pending question for this thread
+    let contextHash;
+    let context;
+    for (const [hash, ctx] of pendingQuestionContexts) {
+        if (ctx.thread.id === threadId) {
+            contextHash = hash;
+            context = ctx;
+            break;
+        }
+    }
+    if (!contextHash || !context) {
+        return false;
+    }
+    try {
+        const clientV2 = getOpencodeClientV2(context.directory);
+        if (!clientV2) {
+            throw new Error('OpenCode server not found for directory');
+        }
+        // Preserve already-answered questions, mark unanswered as cancelled
+        const answers = context.questions.map((_, i) => {
+            return context.answers[i] || ['(cancelled - user sent new message)'];
+        });
+        await clientV2.question.reply({
+            requestID: context.requestId,
+            answers,
+        });
+        logger.log(`Cancelled question ${context.requestId} due to new user message`);
+    }
+    catch (error) {
+        logger.error('Failed to cancel question:', error);
+    }
+    // Clean up regardless of whether the API call succeeded
+    pendingQuestionContexts.delete(contextHash);
+    return true;
+}

package/dist/discord-bot.js

@@ -109,7 +109,10 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 const canManageServer = message.member.permissions.has(PermissionsBitField.Flags.ManageGuild);
                 const hasKimakiRole = message.member.roles.cache.some((role) => role.name.toLowerCase() === 'kimaki');
                 if (!isOwner && !isAdmin && !canManageServer && !hasKimakiRole) {
-                    await message.react('🔒');
+                    await message.reply({
+                        content: `You don't have permission to start sessions.\nTo use Kimaki, ask a server admin to give you the **Kimaki** role.`,
+                        flags: SILENT_MESSAGE_FLAGS,
+                    });
                     return;
                 }
             }
@@ -296,6 +299,85 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
             }
         }
     });
+    // Magic prefix used by `kimaki start-session` CLI command to initiate sessions
+    const BOT_SESSION_PREFIX = '🤖 **Bot-initiated session**';
+    // Handle bot-initiated threads created by `kimaki start-session`
+    discordClient.on(Events.ThreadCreate, async (thread, newlyCreated) => {
+        try {
+            if (!newlyCreated) {
+                return;
+            }
+            // Only handle threads in text channels
+            const parent = thread.parent;
+            if (!parent || parent.type !== ChannelType.GuildText) {
+                return;
+            }
+            // Get the starter message to check for magic prefix
+            const starterMessage = await thread.fetchStarterMessage().catch(() => null);
+            if (!starterMessage) {
+                discordLogger.log(`[THREAD_CREATE] Could not fetch starter message for thread ${thread.id}`);
+                return;
+            }
+            // Only handle messages from this bot with the magic prefix
+            if (starterMessage.author.id !== discordClient.user?.id) {
+                return;
+            }
+            if (!starterMessage.content.startsWith(BOT_SESSION_PREFIX)) {
+                return;
+            }
+            discordLogger.log(`[BOT_SESSION] Detected bot-initiated thread: ${thread.name}`);
+            // Extract the prompt (everything after the prefix)
+            const prompt = starterMessage.content.slice(BOT_SESSION_PREFIX.length).trim();
+            if (!prompt) {
+                discordLogger.log(`[BOT_SESSION] No prompt found in starter message`);
+                return;
+            }
+            // Extract directory from parent channel topic
+            if (!parent.topic) {
+                discordLogger.log(`[BOT_SESSION] Parent channel has no topic`);
+                return;
+            }
+            const extracted = extractTagsArrays({
+                xml: parent.topic,
+                tags: ['kimaki.directory', 'kimaki.app'],
+            });
+            const projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
+            const channelAppId = extracted['kimaki.app']?.[0]?.trim();
+            if (!projectDirectory) {
+                discordLogger.log(`[BOT_SESSION] No kimaki.directory in parent channel topic`);
+                return;
+            }
+            if (channelAppId && channelAppId !== currentAppId) {
+                discordLogger.log(`[BOT_SESSION] Channel belongs to different bot app`);
+                return;
+            }
+            if (!fs.existsSync(projectDirectory)) {
+                discordLogger.error(`[BOT_SESSION] Directory does not exist: ${projectDirectory}`);
+                await thread.send({
+                    content: `✗ Directory does not exist: ${JSON.stringify(projectDirectory)}`,
+                    flags: SILENT_MESSAGE_FLAGS,
+                });
+                return;
+            }
+            discordLogger.log(`[BOT_SESSION] Starting session for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}..."`);
+            await handleOpencodeSession({
+                prompt,
+                thread,
+                projectDirectory,
+                channelId: parent.id,
+            });
+        }
+        catch (error) {
+            voiceLogger.error('[BOT_SESSION] Error handling bot-initiated thread:', error);
+            try {
+                const errMsg = error instanceof Error ? error.message : String(error);
+                await thread.send({ content: `Error: ${errMsg}`, flags: SILENT_MESSAGE_FLAGS });
+            }
+            catch {
+                // Ignore send errors
+            }
+        }
+    });
     await discordClient.login(token);
     const handleShutdown = async (signal, { skipExit = false } = {}) => {
         discordLogger.log(`Received ${signal}, cleaning up...`);

package/dist/discord-utils.js

@@ -5,6 +5,7 @@ import { ChannelType, } from 'discord.js';
 import { Lexer } from 'marked';
 import { extractTagsArrays } from './xml.js';
 import { formatMarkdownTables } from './format-tables.js';
+import { unnestCodeBlocksFromLists } from './unnest-code-blocks.js';
 import { createLogger } from './logger.js';
 const discordLogger = createLogger('DISCORD');
 export const SILENT_MESSAGE_FLAGS = 4 | 4096;
@@ -92,7 +93,8 @@ export function splitMarkdownForDiscord({ content, maxLength, }) {
                 }
                 // calculate overhead for code block markers
                 const codeBlockOverhead = line.inCodeBlock ? ('```' + line.lang + '\n').length + '```\n'.length : 0;
-                const availablePerChunk = maxLength - codeBlockOverhead - 50; // safety margin
+                // ensure at least 10 chars available, even if maxLength is very small
+                const availablePerChunk = Math.max(10, maxLength - codeBlockOverhead - 50);
                 const pieces = splitLongLine(line.text, availablePerChunk, line.inCodeBlock);
                 for (let i = 0; i < pieces.length; i++) {
                     const piece = pieces[i];
@@ -156,6 +158,7 @@ export function splitMarkdownForDiscord({ content, maxLength, }) {
 export async function sendThreadMessage(thread, content, options) {
     const MAX_LENGTH = 2000;
     content = formatMarkdownTables(content);
+    content = unnestCodeBlocksFromLists(content);
     content = escapeBackticksInCodeBlocks(content);
     // If custom flags provided, send as single message (no chunking)
     if (options?.flags !== undefined) {

package/dist/escape-backticks.test.js

@@ -341,11 +341,19 @@ test('splitMarkdownForDiscord handles very long line inside code block', () => {
     \`\`\`
     ",
       "\`\`\`js
-    veryverylonglinethatexceedsmaxlength
-    \`\`\`
+    veryverylo\`\`\`
     ",
       "\`\`\`js
-    short
+    nglinethat\`\`\`
+    ",
+      "\`\`\`js
+    exceedsmax\`\`\`
+    ",
+      "\`\`\`js
+    length
+    \`\`\`
+    ",
+      "short
     \`\`\`
     ",
     ]

package/dist/session-handler.js

@@ -4,12 +4,12 @@
 import prettyMilliseconds from 'pretty-ms';
 import { getDatabase, getSessionModel, getChannelModel, getSessionAgent, getChannelAgent } from './database.js';
 import { initializeOpencodeForDirectory, getOpencodeServers, getOpencodeClientV2 } from './opencode.js';
-import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from './discord-utils.js';
+import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from './discord-utils.js';
 import { formatPart } from './message-formatting.js';
 import { getOpencodeSystemMessage } from './system-message.js';
 import { createLogger } from './logger.js';
 import { isAbortError } from './utils.js';
-import { showAskUserQuestionDropdowns } from './commands/ask-question.js';
+import { showAskUserQuestionDropdowns, cancelPendingQuestion } from './commands/ask-question.js';
 import { showPermissionDropdown, cleanupPermissionContext } from './commands/permissions.js';
 const sessionLogger = createLogger('SESSION');
 const voiceLogger = createLogger('VOICE');
@@ -154,6 +154,12 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             pendingPermissions.delete(thread.id);
         }
     }
+    // Cancel any pending question tool if user sends a new message
+    const questionCancelled = await cancelPendingQuestion(thread.id);
+    if (questionCancelled) {
+        sessionLogger.log(`[QUESTION] Cancelled pending question due to new message`);
+        await sendThreadMessage(thread, `⚠️ Previous question cancelled - processing your new message`);
+    }
     const abortController = new AbortController();
     abortControllers.set(session.id, abortController);
     if (existingController) {
@@ -281,7 +287,8 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                                 const thresholdCrossed = Math.floor(currentPercentage / 10) * 10;
                                 if (thresholdCrossed > lastDisplayedContextPercentage && thresholdCrossed >= 10) {
                                     lastDisplayedContextPercentage = thresholdCrossed;
-                                    await sendThreadMessage(thread, `⬥ context usage ${currentPercentage}%`);
+                                    const chunk = `⬦ context usage ${currentPercentage}%`;
+                                    await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS });
                                 }
                             }
                         }
@@ -386,6 +393,13 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                         continue;
                     }
                     sessionLogger.log(`Question requested: id=${questionRequest.id}, questions=${questionRequest.questions.length}`);
+                    // Flush any pending text/reasoning parts before showing the dropdown
+                    // This ensures text the LLM generated before the question tool is shown first
+                    for (const p of currentParts) {
+                        if (p.type !== 'step-start' && p.type !== 'step-finish') {
+                            await sendPartMessage(p);
+                        }
+                    }
                     await showAskUserQuestionDropdowns({
                         thread,
                         sessionId: session.id,
@@ -525,7 +539,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 path: { id: session.id },
                 body: {
                     parts,
-                    system: getOpencodeSystemMessage({ sessionId: session.id }),
+                    system: getOpencodeSystemMessage({ sessionId: session.id, channelId }),
                     model: modelParam,
                     agent: agentPreference,
                 },