kimaki 0.4.75 → 0.4.77

package/dist/adapter-rest-boundary.test.js

@@ -0,0 +1,34 @@
+// Guardrail test to keep REST helpers out of adapter-consumer runtime files.
+// CLI/task-runner/discord-utils must use platform adapter interfaces instead of
+// direct createDiscordRest/discordRoutes/discordApiUrl imports.
+import fs from 'node:fs';
+import path from 'node:path';
+import { describe, expect, test } from 'vitest';
+const TARGET_FILES = [
+    'src/cli.ts',
+    'src/task-runner.ts',
+    'src/discord-utils.ts',
+];
+const PROJECT_ROOT = path.resolve(import.meta.dirname, '..');
+describe('adapter rest boundary', () => {
+    test('forbids direct REST helper imports in migrated files', () => {
+        const violations = TARGET_FILES.flatMap((relativePath) => {
+            const filePath = path.join(PROJECT_ROOT, relativePath);
+            const content = fs.readFileSync(filePath, 'utf8');
+            const matches = [
+                /\bcreateDiscordRest\b/.test(content)
+                    ? 'createDiscordRest'
+                    : null,
+                /\bdiscordRoutes\b/.test(content) ? 'discordRoutes' : null,
+                /\bdiscordApiUrl\b/.test(content) ? 'discordApiUrl' : null,
+            ].filter((match) => {
+                return Boolean(match);
+            });
+            if (matches.length === 0) {
+                return [];
+            }
+            return [`${relativePath}: ${matches.join(', ')}`];
+        });
+        expect(violations).toMatchInlineSnapshot(`[]`);
+    });
+});

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

@@ -10,7 +10,6 @@
 // Uses opencode-deterministic-provider (no real LLM calls).
 // Poll timeouts: 4s max, 100ms interval.
 import fs from 'node:fs';
-import net from 'node:net';
 import path from 'node:path';
 import url from 'node:url';
 import { describe, beforeAll, afterAll, test, expect, } from 'vitest';
@@ -24,7 +23,7 @@ import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChann
 import { getPrisma } from './db.js';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { initializeOpencodeForDirectory, stopOpencodeServer } from './opencode.js';
-import { cleanupTestSessions, waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
+import { chooseLockPort, cleanupTestSessions, waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
 import { buildQuickAgentCommandDescription } from './commands/agent.js';
 const TEST_USER_ID = '200000000000000920';
 const TEXT_CHANNEL_ID = '200000000000000921';
@@ -41,23 +40,6 @@ function createRunDirectories() {
     fs.mkdirSync(projectDirectory, { recursive: true });
     return { root, dataDir, projectDirectory };
 }
-function chooseLockPort() {
-    return new Promise((resolve, reject) => {
-        const server = net.createServer();
-        server.listen(0, () => {
-            const address = server.address();
-            if (!address || typeof address === 'string') {
-                server.close();
-                reject(new Error('Failed to resolve lock port'));
-                return;
-            }
-            const port = address.port;
-            server.close(() => {
-                resolve(port);
-            });
-        });
-    });
-}
 function createDiscordJsClient({ restUrl }) {
     return new Client({
         intents: [
@@ -158,7 +140,7 @@ describe('agent model resolution', () => {
     beforeAll(async () => {
         testStartTime = Date.now();
         directories = createRunDirectories();
-        const lockPort = await chooseLockPort();
+        const lockPort = chooseLockPort({ key: TEXT_CHANNEL_ID });
         process.env['KIMAKI_LOCK_PORT'] = String(lockPort);
         setDataDir(directories.dataDir);
         previousDefaultVerbosity = store.getState().defaultVerbosity;

package/dist/cli.js

@@ -13,6 +13,7 @@ import { formatWorktreeName } from './commands/new-worktree.js';
 import { WORKTREE_PREFIX } from './commands/merge-worktree.js';
 import { sendWelcomeMessage } from './onboarding-welcome.js';
 import { buildOpencodeEventLogLine } from './session-handler/opencode-session-event-log.js';
+import { selectResolvedCommand } from './opencode-command.js';
 import yaml from 'js-yaml';
 import { Events, ChannelType, ActivityType, Routes, SlashCommandBuilder, AttachmentBuilder, } from 'discord.js';
 import { createDiscordRest, discordApiUrl, getDiscordRestApiUrl, getGatewayProxyRestBaseUrl } from './discord-urls.js';
@@ -192,10 +193,11 @@ function exitNonInteractiveSetup() {
 }
 // Emit a structured JSON line on stdout for non-TTY consumers (cloud sandboxes, CI).
 // Each line is a self-contained JSON object with a "type" field for easy parsing.
-// Consumers can detect these by reading stdout line-by-line and JSON.parse-ing lines
-// that start with '{'.
+// Lines are prefixed with "data: " and terminated with "\n\n" (SSE format) so consumers
+// can use the eventsource-parser npm package to robustly extract JSON events from noisy
+// process output (other log lines, warnings, etc. are ignored by the parser).
 function emitJsonEvent(event) {
-    process.stdout.write(JSON.stringify(event) + '\n');
+    process.stdout.write(`data: ${JSON.stringify(event)}\n\n`);
 }
 async function resolveGatewayInstallCredentials() {
     if (!KIMAKI_GATEWAY_APP_ID) {
@@ -341,7 +343,11 @@ async function ensureCommandAvailable({ name, envPathKey, installUnix, installWi
     const foundInPath = await execAsync(`${whichCmd} ${name}`, {
         env: process.env,
     }).then((result) => {
-        return result.stdout.trim();
+        const resolved = selectResolvedCommand({
+            output: result.stdout,
+            isWindows,
+        });
+        return resolved || '';
     }, () => {
         return '';
     });
@@ -958,6 +964,42 @@ function showReadyMessage({ kimakiChannels, createdChannels, }) {
     }
     note('Leave this process running to keep the bot active.\n\nIf you close this process or restart your machine, run `npx kimaki` again to start the bot.', '⚠️  Keep Running');
 }
+/**
+ * Create the default kimaki channel in each guild and send a welcome message.
+ * Idempotent: skips guilds that already have the channel.
+ * Extracted so both the interactive and headless startup paths share the same logic.
+ */
+async function ensureDefaultChannelsWithWelcome({ guilds, discordClient, appId, isGatewayMode, installerDiscordUserId, }) {
+    const created = [];
+    for (const guild of guilds) {
+        try {
+            const result = await createDefaultKimakiChannel({
+                guild,
+                botName: discordClient.user?.username,
+                appId,
+                isGatewayMode,
+            });
+            if (result) {
+                created.push({
+                    name: result.channelName,
+                    id: result.textChannelId,
+                    guildId: guild.id,
+                });
+                // Send welcome message to the newly created default channel.
+                // Mention the installer so they get a notification.
+                const mentionUserId = installerDiscordUserId || guild.ownerId;
+                await sendWelcomeMessage({
+                    channel: result.textChannel,
+                    mentionUserId,
+                });
+            }
+        }
+        catch (error) {
+            cliLogger.warn(`Failed to create default kimaki channel in ${guild.name}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return created;
+}
 /**
  * Background initialization for quick start mode.
  * Starts OpenCode server and registers slash commands without blocking bot startup.
@@ -1136,7 +1178,7 @@ async function resolveCredentials({ forceRestartOnboarding, forceGateway, gatewa
             emitJsonEvent({ type: 'install_url', url: oauthUrl });
         }
         // Poll until the user installs the bot in a Discord server.
-        // 600 attempts x 2s = 20 minutes timeout.
+        // 100 attempts x 3s = 5 minutes timeout.
         const s = isInteractive ? spinner() : undefined;
         s?.start('Waiting for a Discord server with the bot installed...');
         const pollUrl = new URL('/api/onboarding/status', KIMAKI_WEBSITE_URL);
@@ -1144,9 +1186,9 @@ async function resolveCredentials({ forceRestartOnboarding, forceGateway, gatewa
         pollUrl.searchParams.set('secret', clientSecret);
         let guildId;
         let installerDiscordUserId;
-        for (let attempt = 0; attempt < 600; attempt++) {
+        for (let attempt = 0; attempt < 100; attempt++) {
             await new Promise((resolve) => {
-                setTimeout(resolve, 2000);
+                setTimeout(resolve, 3000);
             });
             // Progressive hints for interactive users who may be stuck
             if (isInteractive) {
@@ -1180,9 +1222,9 @@ async function resolveCredentials({ forceRestartOnboarding, forceGateway, gatewa
                 s?.stop('Authorization timed out');
             }
             else {
-                emitJsonEvent({ type: 'error', message: 'Authorization timed out after 20 minutes' });
+                emitJsonEvent({ type: 'error', message: 'Authorization timed out after 5 minutes' });
             }
-            cliLogger.error('Bot authorization timed out after 20 minutes. Please try again.');
+            cliLogger.error('Bot authorization timed out after 5 minutes. Please try again.');
             process.exit(EXIT_NO_RESTART);
         }
         if (isInteractive) {
@@ -1454,7 +1496,8 @@ async function run({ restartOnboarding, addChannels, useWorktrees, enableVoiceCh
         cliLogger.log('Starting Discord bot...');
         await startDiscordBot({ token, appId, discordClient, useWorktrees });
         cliLogger.log('Discord bot is running!');
-        // Background channel sync + role reconciliation — never blocks ready state.
+        // Background channel sync + role reconciliation + default channel creation.
+        // Never blocks ready state.
         void (async () => {
             try {
                 const backgroundChannels = await collectKimakiChannels({
@@ -1467,6 +1510,20 @@ async function run({ restartOnboarding, addChannels, useWorktrees, enableVoiceCh
             catch (error) {
                 cliLogger.warn('Background channel sync failed:', error instanceof Error ? error.message : String(error));
             }
+            // Create default kimaki channel + welcome message in each guild.
+            // Runs after channel sync so existing channels are detected correctly.
+            try {
+                await ensureDefaultChannelsWithWelcome({
+                    guilds,
+                    discordClient,
+                    appId,
+                    isGatewayMode,
+                    installerDiscordUserId,
+                });
+            }
+            catch (error) {
+                cliLogger.warn('Background default channel creation failed:', error instanceof Error ? error.message : String(error));
+            }
         })();
         // Background: OpenCode init + slash command registration (non-blocking)
         void backgroundInit({
@@ -1609,33 +1666,14 @@ async function run({ restartOnboarding, addChannels, useWorktrees, enableVoiceCh
         }
         // Create default kimaki channel for general-purpose tasks.
         // Runs for every guild the bot is in, idempotent (skips if already exists).
-        for (const guild of guilds) {
-            try {
-                const result = await createDefaultKimakiChannel({
-                    guild,
-                    botName: discordClient.user?.username,
-                    appId,
-                    isGatewayMode,
-                });
-                if (result) {
-                    createdChannels.push({
-                        name: result.channelName,
-                        id: result.textChannelId,
-                        guildId: guild.id,
-                    });
-                    // Send welcome message to the newly created default channel.
-                    // Mention the installer so they get a notification.
-                    const mentionUserId = installerDiscordUserId || guild.ownerId;
-                    await sendWelcomeMessage({
-                        channel: result.textChannel,
-                        mentionUserId,
-                    });
-                }
-            }
-            catch (error) {
-                cliLogger.warn(`Failed to create default kimaki channel in ${guild.name}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
+        const defaultChannelResults = await ensureDefaultChannelsWithWelcome({
+            guilds,
+            discordClient,
+            appId,
+            isGatewayMode,
+            installerDiscordUserId,
+        });
+        createdChannels.push(...defaultChannelResults);
         // Log available user commands
         const registrableCommands = allUserCommands.filter((cmd) => !SKIP_USER_COMMANDS.includes(cmd.name));
         if (registrableCommands.length > 0) {

package/dist/commands/ask-question.js

@@ -29,27 +29,28 @@ export async function showAskUserQuestionDropdowns({ thread, sessionId, director
         contextHash,
     };
     pendingQuestionContexts.set(contextHash, context);
-    // Auto-answer on TTL expiry so the OpenCode session doesn't hang forever
-    // waiting for a question reply that will never come.
+    // On TTL expiry: hide the dropdown UI and abort the session so OpenCode
+    // unblocks. We intentionally do NOT call question.reply() — sending 'Other'
+    // made the model think the user chose an option when they didn't.
     setTimeout(async () => {
         const ctx = pendingQuestionContexts.get(contextHash);
         if (!ctx) {
             return;
         }
+        // Delete context first so the dropdown becomes inert immediately.
+        // Without this, a user clicking during the abort() await would still
+        // be accepted by handleAskQuestionSelectMenu, then abort() would
+        // kill that valid run.
+        pendingQuestionContexts.delete(contextHash);
+        // Abort the session so OpenCode isn't stuck waiting for a reply
         const client = getOpencodeClient(ctx.directory);
         if (client) {
-            const answers = ctx.questions.map((_, i) => {
-                return ctx.answers[i] || ['Other'];
-            });
-            await client.question.reply({
-                requestID: ctx.requestId,
-                directory: ctx.directory,
-                answers,
+            await client.session.abort({
+                sessionID: ctx.sessionId,
             }).catch((error) => {
-                logger.error('Failed to auto-answer expired question:', error);
+                logger.error('Failed to abort session after question expiry:', error);
             });
         }
-        pendingQuestionContexts.delete(contextHash);
     }, QUESTION_CONTEXT_TTL_MS).unref();
     // Send one message per question with its dropdown directly underneath
     for (let i = 0; i < input.questions.length; i++) {
@@ -206,6 +207,11 @@ export function parseAskUserQuestionTool(part) {
 /**
  * Cancel a pending question for a thread (e.g., when user sends a new message).
  * Sends the user's message as the answer to OpenCode so the model sees their actual response.
+ *
+ * Returns 'replied' if the question was answered successfully (caller should NOT
+ * enqueue the user message as a new prompt — it was consumed as the answer).
+ * Returns 'reply-failed' if reply failed (context kept pending so TTL can retry).
+ * Returns 'no-pending' if no question was pending for this thread.
  */
 export async function cancelPendingQuestion(threadId, userMessage) {
     // Find pending question for this thread
@@ -219,17 +225,22 @@ export async function cancelPendingQuestion(threadId, userMessage) {
         }
     }
     if (!contextHash || !context) {
-        return false;
+        return 'no-pending';
+    }
+    // undefined means teardown/cleanup — just remove context, don't reply.
+    // The session is already being torn down. Empty string '' is a valid
+    // user message (attachment-only, voice, etc.) and must still go through.
+    if (userMessage === undefined) {
+        pendingQuestionContexts.delete(contextHash);
+        return 'no-pending';
     }
     try {
         const client = getOpencodeClient(context.directory);
         if (!client) {
             throw new Error('OpenCode server not found for directory');
         }
-        // Use user's message as answer if provided, otherwise mark as "Other"
-        const customAnswer = userMessage || 'Other';
         const answers = context.questions.map((_, i) => {
-            return context.answers[i] || [customAnswer];
+            return context.answers[i] || [userMessage];
         });
         await client.question.reply({
             requestID: context.requestId,
@@ -240,8 +251,10 @@ export async function cancelPendingQuestion(threadId, userMessage) {
     }
     catch (error) {
         logger.error('Failed to answer question:', error);
+        // Keep context pending so TTL can still fire.
+        // Caller should not consume the user message since reply failed.
+        return 'reply-failed';
     }
-    // Clean up regardless of whether the API call succeeded
     pendingQuestionContexts.delete(contextHash);
-    return true;
+    return 'replied';
 }

package/dist/commands/channel-ref.js

@@ -0,0 +1,16 @@
+// Helpers for working with normalized platform channel references in commands.
+export function isThreadChannel(channel) {
+    return channel?.kind === 'thread';
+}
+export function isTextChannel(channel) {
+    return channel?.kind === 'text';
+}
+export function getRootChannelId(channel) {
+    if (!channel) {
+        return null;
+    }
+    if (channel.kind === 'thread') {
+        return channel.parentId || channel.id;
+    }
+    return channel.id;
+}

package/dist/commands/merge-worktree.js

@@ -6,7 +6,7 @@ import { getThreadWorktree, getThreadSession, getChannelDirectory, } from '../da
 import { createLogger, LogPrefix } from '../logger.js';
 import { notifyError } from '../sentry.js';
 import { mergeWorktree, listBranchesByLastCommit, validateBranchRef } from '../worktrees.js';
-import { sendThreadMessage, resolveWorkingDirectory, resolveTextChannel, } from '../discord-utils.js';
+import { sendThreadMessage, resolveWorkingDirectory, resolveProjectDirectoryFromAutocomplete, } from '../discord-utils.js';
 import { getOrCreateRuntime, } from '../session-handler/thread-session-runtime.js';
 import { RebaseConflictError, DirtyWorktreeError } from '../errors.js';
 const logger = createLogger(LogPrefix.WORKTREE);
@@ -131,22 +131,10 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
 export async function handleMergeWorktreeAutocomplete({ interaction, }) {
     try {
         const focusedValue = interaction.options.getFocused();
-        let projectDirectory;
-        // Try to get directory from worktree info (we're in a thread)
-        if (interaction.channel?.isThread()) {
-            const worktreeInfo = await getThreadWorktree(interaction.channel.id);
-            if (worktreeInfo?.project_directory) {
-                projectDirectory = worktreeInfo.project_directory;
-            }
-        }
-        // Fallback: resolve from parent channel
-        if (!projectDirectory && interaction.channel) {
-            const textChannel = await resolveTextChannel(interaction.channel);
-            if (textChannel) {
-                const channelConfig = await getChannelDirectory(textChannel.id);
-                projectDirectory = channelConfig?.directory;
-            }
-        }
+        // interaction.channel can be null when the channel isn't cached
+        // (common with gateway-proxy). Use channelId which is always available
+        // from the raw interaction payload.
+        const projectDirectory = await resolveProjectDirectoryFromAutocomplete(interaction);
         if (!projectDirectory) {
             await interaction.respond([]);
             return;

package/dist/commands/new-worktree.js

@@ -4,7 +4,7 @@
 import { ChannelType, REST, } from 'discord.js';
 import fs from 'node:fs';
 import { createPendingWorktree, setWorktreeReady, setWorktreeError, getChannelDirectory, getThreadWorktree, } from '../database.js';
-import { SILENT_MESSAGE_FLAGS, reactToThread, resolveTextChannel, } from '../discord-utils.js';
+import { SILENT_MESSAGE_FLAGS, reactToThread, resolveProjectDirectoryFromAutocomplete, } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { notifyError } from '../sentry.js';
 import { createWorktreeWithSubmodules, execAsync, listBranchesByLastCommit, validateBranchRef, } from '../worktrees.js';
@@ -313,14 +313,10 @@ async function handleWorktreeInThread({ command, thread, }) {
 export async function handleNewWorktreeAutocomplete({ interaction, }) {
     try {
         const focusedValue = interaction.options.getFocused();
-        let projectDirectory;
-        if (interaction.channel) {
-            const textChannel = await resolveTextChannel(interaction.channel);
-            if (textChannel) {
-                const channelConfig = await getChannelDirectory(textChannel.id);
-                projectDirectory = channelConfig?.directory;
-            }
-        }
+        // interaction.channel can be null when the channel isn't cached
+        // (common with gateway-proxy). Use channelId which is always available
+        // from the raw interaction payload.
+        const projectDirectory = await resolveProjectDirectoryFromAutocomplete(interaction);
         if (!projectDirectory) {
             await interaction.respond([]);
             return;

package/dist/commands/permissions.js

@@ -118,9 +118,83 @@ export async function showPermissionButtons({ thread, permission, directory, per
         components: [actionRow],
         flags: NOTIFY_MESSAGE_FLAGS | MessageFlags.SuppressEmbeds,
     });
+    context.messageId = permissionMessage.id;
     logger.log(`Showed permission buttons for ${permission.id}`);
     return { messageId: permissionMessage.id, contextHash };
 }
+function updatePermissionMessage({ context, status, }) {
+    if (!context.messageId) {
+        return;
+    }
+    context.thread.messages
+        .fetch(context.messageId)
+        .then((message) => {
+        const patternStr = compactPermissionPatterns(context.permission.patterns).join(', ');
+        const externalDirLine = context.permission.permission === 'external_directory'
+            ? 'Agent is accessing files outside the project. [Learn more](https://opencode.ai/docs/permissions/#external-directories)\n'
+            : '';
+        return message.edit({
+            content: `⚠️ **Permission Required**\n` +
+                `**Type:** \`${context.permission.permission}\`\n` +
+                externalDirLine +
+                (patternStr ? `**Pattern:** \`${patternStr}\`\n` : '') +
+                status,
+            components: [],
+        });
+    })
+        .catch((error) => {
+        logger.error('Failed to update permission message:', error);
+    });
+}
+export async function cancelPendingPermission(threadId) {
+    const contexts = Array.from(pendingPermissionContexts.values()).filter((context) => {
+        return context.thread.id === threadId;
+    });
+    if (contexts.length === 0) {
+        return false;
+    }
+    let cancelledCount = 0;
+    for (const context of contexts) {
+        const pendingContext = takePendingPermissionContext(context.contextHash);
+        if (!pendingContext) {
+            continue;
+        }
+        const client = getOpencodeClient(pendingContext.directory);
+        if (!client) {
+            pendingPermissionContexts.set(pendingContext.contextHash, pendingContext);
+            logger.error('Failed to dismiss pending permission: OpenCode server not found');
+            continue;
+        }
+        const requestIds = pendingContext.requestIds.length > 0
+            ? pendingContext.requestIds
+            : [pendingContext.permission.id];
+        const result = await Promise.all(requestIds.map((requestId) => {
+            return client.permission.reply({
+                requestID: requestId,
+                directory: pendingContext.permissionDirectory,
+                reply: 'reject',
+            });
+        })).then(() => {
+            return 'ok';
+        }).catch((error) => {
+            pendingPermissionContexts.set(pendingContext.contextHash, pendingContext);
+            logger.error('Failed to dismiss pending permission:', error);
+            return 'error';
+        });
+        if (result === 'error') {
+            continue;
+        }
+        updatePermissionMessage({
+            context: pendingContext,
+            status: '_Permission dismissed - user sent a new message._',
+        });
+        cancelledCount++;
+    }
+    if (cancelledCount > 0) {
+        logger.log(`Dismissed ${cancelledCount} pending permission request(s) for thread ${threadId}`);
+    }
+    return cancelledCount > 0;
+}
 /**
  * Handle button click for permission.
  */
@@ -166,17 +240,9 @@ export async function handlePermissionButton(interaction) {
                     return '❌ Permission **rejected**';
             }
         })();
-        const patternStr = compactPermissionPatterns(context.permission.patterns).join(', ');
-        const externalDirLine = context.permission.permission === 'external_directory'
-            ? `Agent is accessing files outside the project. [Learn more](https://opencode.ai/docs/permissions/#external-directories)\n`
-            : '';
-        await interaction.editReply({
-            content: `⚠️ **Permission Required**\n` +
-                `**Type:** \`${context.permission.permission}\`\n` +
-                externalDirLine +
-                (patternStr ? `**Pattern:** \`${patternStr}\`\n` : '') +
-                resultText,
-            components: [], // Remove the buttons
+        updatePermissionMessage({
+            context,
+            status: resultText,
         });
         logger.log(`Permission ${context.permission.id} ${response} (${requestIds.length} request(s))`);
     }

package/dist/commands/resume.js

@@ -3,7 +3,7 @@ import { ChannelType, ThreadAutoArchiveDuration, } from 'discord.js';
 import fs from 'node:fs';
 import { getChannelDirectory, setThreadSession, setPartMessagesBatch, getAllThreadSessionIds, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
-import { sendThreadMessage, resolveTextChannel } from '../discord-utils.js';
+import { sendThreadMessage, resolveProjectDirectoryFromAutocomplete } from '../discord-utils.js';
 import { collectLastAssistantParts } from '../message-formatting.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
@@ -100,14 +100,10 @@ export async function handleResumeCommand({ command, }) {
 }
 export async function handleResumeAutocomplete({ interaction, }) {
     const focusedValue = interaction.options.getFocused();
-    let projectDirectory;
-    if (interaction.channel) {
-        const textChannel = await resolveTextChannel(interaction.channel);
-        if (textChannel) {
-            const channelConfig = await getChannelDirectory(textChannel.id);
-            projectDirectory = channelConfig?.directory;
-        }
-    }
+    // interaction.channel can be null when the channel isn't cached
+    // (common with gateway-proxy). Use channelId which is always available
+    // from the raw interaction payload.
+    const projectDirectory = await resolveProjectDirectoryFromAutocomplete(interaction);
     if (!projectDirectory) {
         await interaction.respond([]);
         return;

package/dist/commands/session.js

@@ -4,7 +4,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { getChannelDirectory } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
-import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { SILENT_MESSAGE_FLAGS, resolveProjectDirectoryFromAutocomplete } from '../discord-utils.js';
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
@@ -80,14 +80,10 @@ export async function handleSessionCommand({ command, appId, }) {
 }
 async function handleAgentAutocomplete({ interaction, }) {
     const focusedValue = interaction.options.getFocused();
-    let projectDirectory;
-    if (interaction.channel &&
-        interaction.channel.type === ChannelType.GuildText) {
-        const channelConfig = await getChannelDirectory(interaction.channel.id);
-        if (channelConfig) {
-            projectDirectory = channelConfig.directory;
-        }
-    }
+    // interaction.channel can be null when the channel isn't cached
+    // (common with gateway-proxy). Use channelId which is always available
+    // from the raw interaction payload.
+    const projectDirectory = await resolveProjectDirectoryFromAutocomplete(interaction);
     if (!projectDirectory) {
         await interaction.respond([]);
         return;
@@ -139,14 +135,7 @@ export async function handleSessionAutocomplete({ interaction, }) {
         .map((f) => f.trim())
         .filter((f) => f);
     const currentQuery = (parts[parts.length - 1] || '').trim();
-    let projectDirectory;
-    if (interaction.channel &&
-        interaction.channel.type === ChannelType.GuildText) {
-        const channelConfig = await getChannelDirectory(interaction.channel.id);
-        if (channelConfig) {
-            projectDirectory = channelConfig.directory;
-        }
-    }
+    const projectDirectory = await resolveProjectDirectoryFromAutocomplete(interaction);
     if (!projectDirectory) {
         await interaction.respond([]);
         return;