kimaki 0.4.76 → 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';
@@ -342,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 '';
     });
@@ -1173,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);
@@ -1181,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) {
@@ -1217,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) {
@@ -1507,13 +1512,18 @@ async function run({ restartOnboarding, addChannels, useWorktrees, enableVoiceCh
             }
             // Create default kimaki channel + welcome message in each guild.
             // Runs after channel sync so existing channels are detected correctly.
-            await ensureDefaultChannelsWithWelcome({
-                guilds,
-                discordClient,
-                appId,
-                isGatewayMode,
-                installerDiscordUserId,
-            });
+            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({

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;

package/dist/discord-bot.js

@@ -14,6 +14,7 @@ import { preprocessExistingThreadMessage, preprocessNewThreadMessage, } from './
 import { cancelPendingActionButtons } from './commands/action-buttons.js';
 import { cancelPendingQuestion } from './commands/ask-question.js';
 import { cancelPendingFileUpload } from './commands/file-upload.js';
+import { cancelPendingPermission } from './commands/permissions.js';
 import { cancelHtmlActionsForThread } from './html-actions.js';
 import { ensureKimakiCategory, ensureKimakiAudioCategory, createProjectChannels, getChannelsWithDescriptions, } from './channel-management.js';
 import { voiceConnections, cleanupVoiceConnection, registerVoiceStateHandler, } from './voice-handler.js';
@@ -330,19 +331,6 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             if (isThread) {
                 const thread = channel;
                 discordLogger.log(`Message in thread ${thread.name} (${thread.id})`);
-                // Cancel interactive UI when a real user sends a message.
-                // If a question was pending and answered with the user's text,
-                // early-return: the message was consumed as the question answer
-                // and must NOT also be sent as a new prompt (causes abort loops).
-                if (!message.author.bot && !isCliInjectedPrompt) {
-                    cancelPendingActionButtons(thread.id);
-                    cancelHtmlActionsForThread(thread.id);
-                    const questionResult = await cancelPendingQuestion(thread.id, message.content);
-                    void cancelPendingFileUpload(thread.id);
-                    if (questionResult === 'replied') {
-                        return;
-                    }
-                }
                 const parent = thread.parent;
                 let projectDirectory;
                 if (parent) {
@@ -424,6 +412,23 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     channelId: parent?.id || undefined,
                     appId: currentAppId,
                 });
+                // Cancel interactive UI when a real user sends a message.
+                // If a question was pending and answered with the user's text,
+                // early-return: the message was consumed as the question answer
+                // and must NOT also be sent as a new prompt (causes abort loops).
+                if (!message.author.bot && !isCliInjectedPrompt) {
+                    cancelPendingActionButtons(thread.id);
+                    cancelHtmlActionsForThread(thread.id);
+                    const dismissedPermission = await cancelPendingPermission(thread.id);
+                    if (dismissedPermission) {
+                        runtime.abortActiveRun('user sent a new message while permission was pending');
+                    }
+                    const questionResult = await cancelPendingQuestion(thread.id, message.content);
+                    void cancelPendingFileUpload(thread.id);
+                    if (questionResult === 'replied') {
+                        return;
+                    }
+                }
                 // Expensive pre-processing (voice transcription, context fetch,
                 // attachment download) runs inside the runtime's serialized
                 // preprocess chain, preserving Discord arrival order without

package/dist/discord-js-import-boundary.test.js

@@ -0,0 +1,62 @@
+// Guardrail test for adapter boundary imports.
+// Runtime modules must not import discord.js directly outside the Discord adapter,
+// forum-sync bridge, and voice handler.
+import fs from 'node:fs';
+import path from 'node:path';
+import { describe, expect, test } from 'vitest';
+const SRC_DIR = path.resolve(import.meta.dirname);
+function collectTsFiles(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    return entries.flatMap((entry) => {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            return collectTsFiles(fullPath);
+        }
+        if (!entry.name.endsWith('.ts')) {
+            return [];
+        }
+        if (entry.name.endsWith('.test.ts')) {
+            return [];
+        }
+        if (entry.name.includes('e2e')) {
+            return [];
+        }
+        return [fullPath];
+    });
+}
+function toWorkspaceRelative(filePath) {
+    return path.relative(path.resolve(import.meta.dirname, '..'), filePath);
+}
+function isAllowedBoundaryFile(relativePath) {
+    if (relativePath === 'src/platform/discord-adapter.ts') {
+        return true;
+    }
+    if (relativePath === 'src/voice-handler.ts') {
+        return true;
+    }
+    if (relativePath.startsWith('src/forum-sync/')) {
+        return true;
+    }
+    return false;
+}
+describe('discord.js import boundary', () => {
+    test('does not import discord.js outside allowed modules', () => {
+        const violations = collectTsFiles(SRC_DIR)
+            .map((filePath) => {
+            return {
+                relativePath: toWorkspaceRelative(filePath),
+                content: fs.readFileSync(filePath, 'utf8'),
+            };
+        })
+            .filter(({ relativePath }) => {
+            return !isAllowedBoundaryFile(relativePath);
+        })
+            .filter(({ content }) => {
+            return /from\s+['"]discord\.js['"]/.test(content);
+        })
+            .map(({ relativePath }) => {
+            return relativePath;
+        });
+        expect(violations).toMatchInlineSnapshot(`[]`);
+    });
+});

package/dist/discord-utils.js

@@ -480,6 +480,50 @@ export async function getKimakiMetadata(textChannel) {
         projectDirectory: channelConfig.directory,
     };
 }
+/**
+ * Resolve project directory from an autocomplete interaction.
+ * Uses interaction.channelId (always available from raw payload) instead of
+ * interaction.channel (cache-based getter, often null with gateway-proxy).
+ * Checks the channel ID directly in DB, then tries thread worktree lookup,
+ * then falls back to fetching the channel to resolve thread parent.
+ */
+export async function resolveProjectDirectoryFromAutocomplete(interaction) {
+    const channelId = interaction.channelId;
+    // Direct channel lookup — works when the command is run from a project text channel
+    const channelConfig = await getChannelDirectory(channelId);
+    if (channelConfig) {
+        return channelConfig.directory;
+    }
+    // If we're in a thread, try worktree info first (has project_directory)
+    const worktreeInfo = await getThreadWorktree(channelId);
+    if (worktreeInfo?.project_directory) {
+        return worktreeInfo.project_directory;
+    }
+    // Thread fallback: resolve parent channel ID and look up its directory.
+    // Try cached channel first, then fetch if cache misses (gateway-proxy scenario).
+    const cachedParentId = interaction.channel?.isThread() ? interaction.channel.parentId : null;
+    if (cachedParentId) {
+        const parentConfig = await getChannelDirectory(cachedParentId);
+        if (parentConfig) {
+            return parentConfig.directory;
+        }
+    }
+    // Last resort: fetch the channel from Discord API to get parentId for threads
+    // when the channel isn't cached at all (common with gateway-proxy).
+    if (!cachedParentId) {
+        const fetched = await errore.tryAsync({
+            try: () => { return interaction.client.channels.fetch(channelId); },
+            catch: (e) => { return e; },
+        });
+        if (!(fetched instanceof Error) && fetched?.isThread() && fetched.parentId) {
+            const parentConfig = await getChannelDirectory(fetched.parentId);
+            if (parentConfig) {
+                return parentConfig.directory;
+            }
+        }
+    }
+    return undefined;
+}
 /**
  * Resolve the working directory for a channel or thread.
  * Returns both the base project directory (for server init) and the working directory

package/dist/event-stream-real-capture.e2e.test.js

@@ -2,7 +2,6 @@
 // Uses opencode-cached-provider + Gemini to record real tool/lifecycle streams
 // (task, interruption, permission, action buttons, and question flows).
 import fs from 'node:fs';
-import net from 'node:net';
 import path from 'node:path';
 import { afterAll, afterEach, beforeAll, describe, expect, test } from 'vitest';
 import { ChannelType, Client, GatewayIntentBits, Partials } from 'discord.js';
@@ -13,7 +12,7 @@ import { store } from './store.js';
 import { startDiscordBot } from './discord-bot.js';
 import { closeDatabase, getChannelVerbosity, initDatabase, setBotToken, setChannelDirectory, setChannelVerbosity, } from './database.js';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
-import { cleanupTestSessions } from './test-utils.js';
+import { chooseLockPort, cleanupTestSessions } from './test-utils.js';
 import { waitForBotMessageContaining, waitForBotReplyAfterUserMessage } from './test-utils.js';
 import { stopOpencodeServer } from './opencode.js';
 import { disposeRuntime, pendingPermissions } from './session-handler/thread-session-runtime.js';
@@ -46,23 +45,6 @@ function createRunDirectories() {
         fixtureOutputDir,
     };
 }
-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: [
@@ -248,7 +230,7 @@ describe('real event stream capture fixtures (cached provider)', () => {
     }
     beforeAll(async () => {
         testStartTime = Date.now();
-        lockPort = await chooseLockPort();
+        lockPort = chooseLockPort({ key: TEXT_CHANNEL_ID });
         listJsonlFiles(directories.sessionEventsDir).forEach((fileName) => {
             fs.rmSync(path.join(directories.sessionEventsDir, fileName), {
                 force: true,