kimaki 0.4.104 → 0.5.0

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

@@ -95,7 +95,7 @@ function createDeterministicMatchers() {
         when: {
             lastMessageRole: 'user',
             latestUserTextIncludes: 'Reply with exactly: reply-context-check',
-            promptTextIncludes: 'This message was a reply to message\n\n<replied-message author="agent-model-tester">\nfirst message in thread\n</replied-message>',
+            rawPromptIncludes: 'This message was a reply to message\n\n<replied-message author="agent-model-tester">\nfirst message in thread\n</replied-message>',
         },
         then: {
             parts: [
@@ -265,7 +265,7 @@ describe('agent model resolution', () => {
         if (warmup instanceof Error) {
             throw warmup;
         }
-    }, 60_000);
+    }, 20_000);
     afterAll(async () => {
         if (directories) {
             await cleanupTestSessions({
@@ -296,7 +296,7 @@ describe('agent model resolution', () => {
         if (directories) {
             fs.rmSync(directories.dataDir, { recursive: true, force: true });
         }
-    }, 10_000);
+    }, 5_000);
     test('new thread uses agent model when channel agent is set', async () => {
         // Set channel agent preference — this simulates /agent selecting test-agent
         await setChannelAgent(TEXT_CHANNEL_ID, 'test-agent');
@@ -377,13 +377,23 @@ describe('agent model resolution', () => {
       `);
     }, 15_000);
     test('reply message injects replied-message context', async () => {
+        const prisma = await getPrisma();
+        await prisma.channel_agents.deleteMany({
+            where: { channel_id: TEXT_CHANNEL_ID },
+        });
+        await prisma.channel_models.deleteMany({
+            where: { channel_id: TEXT_CHANNEL_ID },
+        });
+        const existingThreadIds = new Set((await discord.channel(TEXT_CHANNEL_ID).getThreads()).map((thread) => {
+            return thread.id;
+        }));
         await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
             content: 'first message in thread',
         });
         const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
-            timeout: 4_000,
+            timeout: 6_000,
             predicate: (t) => {
-                return t.name === 'first message in thread';
+                return !existingThreadIds.has(t.id);
             },
         });
         const threadMessagesBeforeReply = await discord.thread(thread.id).getMessages();
@@ -407,31 +417,13 @@ describe('agent model resolution', () => {
             discord,
             threadId: thread.id,
             userId: TEST_USER_ID,
-            text: 'reply-context-ok',
-            timeout: 4_000,
+            text: 'ok',
+            timeout: 6_000,
         });
-        await waitForFooterMessage({
-            discord,
-            threadId: thread.id,
-            timeout: 4_000,
-            afterMessageIncludes: 'reply-context-ok',
-            afterAuthorId: discord.botUserId,
-        });
-        const threadText = (await discord.thread(thread.id).text())
-            .split('\n')
-            .filter((line) => {
-            return !line.startsWith('⬦ info: Context cache discarded:');
-        })
-            .join('\n');
-        expect(threadText).toMatchInlineSnapshot(`
-        "--- from: user (agent-model-tester)
-        first message in thread
-        Reply with exactly: reply-context-check
-        --- from: assistant (TestBot)
-        ⬥ ok
-        ⬥ reply-context-ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
-      `);
+        const threadText = await discord.thread(thread.id).text();
+        expect(threadText).toContain('first message in thread');
+        expect(threadText).toContain('Reply with exactly: reply-context-check');
+        expect(threadText).toContain('⬥ ok');
     }, 15_000);
     test('new thread uses channel model when channel model preference is set', async () => {
         // Clear channel agent so model resolution falls through to channel model

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

@@ -182,7 +182,7 @@ describe('kimaki send --channel thread creation', () => {
         if (warmup instanceof Error) {
             throw warmup;
         }
-    }, 60_000);
+    }, 20_000);
     afterAll(async () => {
         if (directories) {
             await cleanupTestSessions({
@@ -213,7 +213,7 @@ describe('kimaki send --channel thread creation', () => {
         if (directories) {
             fs.rmSync(directories.dataDir, { recursive: true, force: true });
         }
-    }, 10_000);
+    }, 5_000);
     test('kimaki send --prompt "/hello-test-cmd" falls through as text when registeredUserCommands is empty (repro #97)', async () => {
         // Reproduce GitHub #97: when registeredUserCommands is empty (gateway mode
         // startup race, or backgroundInit not complete), the prompt "/hello-test-cmd"

package/dist/commands/add-dir.js

@@ -0,0 +1,122 @@
+// /add-dir command - Expand the current session's external_directory permissions.
+// Resolves the requested directory against the active working directory, then
+// updates the current session permission rules via OpenCode.
+import { ChannelType, MessageFlags, } from 'discord.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getThreadSession } from '../database.js';
+import { buildExternalDirectoryPermissionRules, getOpencodeClient, initializeOpencodeForDirectory, } from '../opencode.js';
+import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.PERMISSIONS);
+const ALL_DIRECTORIES_PATTERN = '*';
+export function resolveDirectoryPermissionPattern({ input, workingDirectory, }) {
+    const trimmedInput = input.trim();
+    if (!trimmedInput) {
+        return new Error('Directory is required');
+    }
+    if (trimmedInput === ALL_DIRECTORIES_PATTERN) {
+        return ALL_DIRECTORIES_PATTERN;
+    }
+    const absolutePath = path.resolve(workingDirectory, trimmedInput);
+    if (!fs.existsSync(absolutePath)) {
+        return new Error(`Directory does not exist: ${absolutePath}`);
+    }
+    let stats;
+    try {
+        stats = fs.statSync(absolutePath);
+    }
+    catch (error) {
+        return new Error(`Failed to inspect directory: ${absolutePath}`, { cause: error });
+    }
+    if (!stats.isDirectory()) {
+        return new Error(`Not a directory: ${absolutePath}`);
+    }
+    return absolutePath.replaceAll('\\', '/');
+}
+export function buildAddDirPermissionRules({ resolvedPattern, }) {
+    return buildExternalDirectoryPermissionRules({
+        resolvedPattern,
+        action: 'allow',
+    });
+}
+export async function handleAddDirCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        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 | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const resolvedDirectories = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolvedDirectories) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const requestedDirectory = command.options.getString('directory', true);
+    const resolvedPattern = resolveDirectoryPermissionPattern({
+        input: requestedDirectory,
+        workingDirectory: resolvedDirectories.workingDirectory,
+    });
+    if (resolvedPattern instanceof Error) {
+        await command.reply({
+            content: resolvedPattern.message,
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const sessionId = await getThreadSession(channel.id);
+    if (!sessionId) {
+        await command.reply({
+            content: 'No active session in this thread',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    const getClient = await initializeOpencodeForDirectory(resolvedDirectories.projectDirectory);
+    if (getClient instanceof Error) {
+        await command.editReply(`Failed to update session permissions: ${getClient.message}`);
+        return;
+    }
+    const client = getOpencodeClient(resolvedDirectories.projectDirectory);
+    if (!client) {
+        await command.editReply('Failed to get OpenCode client');
+        return;
+    }
+    try {
+        const updateResponse = await client.session.update({
+            sessionID: sessionId,
+            permission: buildAddDirPermissionRules({ resolvedPattern }),
+        });
+        if (updateResponse.error) {
+            await command.editReply('Failed to update session permissions');
+            return;
+        }
+        await command.editReply(resolvedPattern === ALL_DIRECTORIES_PATTERN
+            ? 'Updated session permissions: all external directories are now allowed'
+            : `Updated session permissions: allowed \`${resolvedPattern}\``);
+    }
+    catch (error) {
+        logger.error('[ADD-DIR] Failed to update session permissions:', error);
+        await command.editReply(`Failed to update session permissions: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/commands/add-dir.test.js

@@ -0,0 +1,87 @@
+// Tests for /add-dir permission helpers.
+import { describe, expect, test } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import { buildAddDirPermissionRules, resolveDirectoryPermissionPattern, } from './add-dir.js';
+import { buildExternalDirectoryPermissionRules, buildSessionPermissions, } from '../opencode.js';
+describe('resolveDirectoryPermissionPattern', () => {
+    test('resolves relative directories against the working directory', () => {
+        const root = path.resolve(process.cwd(), 'tmp', 'add-dir-test');
+        const nested = path.join(root, 'nested');
+        fs.mkdirSync(nested, { recursive: true });
+        const result = resolveDirectoryPermissionPattern({
+            input: './nested',
+            workingDirectory: root,
+        });
+        expect(result).toBe(nested.replaceAll('\\', '/'));
+    });
+    test('supports allowing every directory with *', () => {
+        expect(buildAddDirPermissionRules({
+            resolvedPattern: '*',
+        })).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "allow",
+          "pattern": "*",
+          "permission": "external_directory",
+        },
+      ]
+    `);
+    });
+    test('builds allow rules for a specific directory', () => {
+        expect(buildAddDirPermissionRules({
+            resolvedPattern: '/repo/extra',
+        })).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "allow",
+          "pattern": "/repo/extra",
+          "permission": "external_directory",
+        },
+        {
+          "action": "allow",
+          "pattern": "/repo/extra/*",
+          "permission": "external_directory",
+        },
+      ]
+    `);
+    });
+    test('builds deny rules for a specific directory', () => {
+        expect(buildExternalDirectoryPermissionRules({
+            resolvedPattern: '/repo',
+            action: 'deny',
+        })).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "/repo",
+          "permission": "external_directory",
+        },
+        {
+          "action": "deny",
+          "pattern": "/repo/*",
+          "permission": "external_directory",
+        },
+      ]
+    `);
+    });
+    test('worktree sessions deny the original checkout last', () => {
+        expect(buildSessionPermissions({
+            directory: '/Users/me/.kimaki/worktrees/hash/feature',
+            originalRepoDirectory: '/Users/me/project',
+        }).slice(-2)).toMatchInlineSnapshot(`
+      [
+        {
+          "action": "deny",
+          "pattern": "/Users/me/project",
+          "permission": "external_directory",
+        },
+        {
+          "action": "deny",
+          "pattern": "/Users/me/project/*",
+          "permission": "external_directory",
+        },
+      ]
+    `);
+    });
+});

package/dist/commands/agent.js

@@ -331,6 +331,7 @@ export async function handleQuickAgentCommand({ command, appId, }) {
                 appId,
                 agentPreference: resolvedAgentName,
                 getClient,
+                directory: context.dir,
             });
         })();
         const modelText = modelInfo.type === 'none' ? '' : `\nModel: *${modelInfo.model}*`;

package/dist/commands/model-variant.js

@@ -96,6 +96,7 @@ export async function handleModelVariantCommand({ interaction, appId, }) {
             channelId: targetChannelId,
             appId,
             getClient,
+            directory: projectDirectory,
         });
     }
     const [currentModelInfo, cascadeVariant, providersResponse] = await Promise.all([
@@ -104,6 +105,7 @@ export async function handleModelVariantCommand({ interaction, appId, }) {
             channelId: targetChannelId,
             appId,
             getClient,
+            directory: projectDirectory,
         }),
         getVariantCascade({
             sessionId,

package/dist/commands/model.js

@@ -30,7 +30,7 @@ function parseModelId(modelString) {
     }
     return undefined;
 }
-export async function ensureSessionPreferencesSnapshot({ sessionId, channelId, appId, getClient, agentOverride, modelOverride, force, }) {
+export async function ensureSessionPreferencesSnapshot({ sessionId, channelId, appId, getClient, directory, agentOverride, modelOverride, force, }) {
     const [sessionAgentPreference, sessionModelPreference] = await Promise.all([
         getSessionAgent(sessionId),
         getSessionModel(sessionId),
@@ -73,6 +73,7 @@ export async function ensureSessionPreferencesSnapshot({ sessionId, channelId, a
         appId,
         agentPreference: bootstrappedAgent,
         getClient,
+        directory,
     });
     if (bootstrappedModel.type === 'none') {
         return;
@@ -93,7 +94,7 @@ export async function ensureSessionPreferencesSnapshot({ sessionId, channelId, a
  * Get the current model info for a channel/session, including where it comes from.
  * Priority: session > agent > channel > global > opencode default
  */
-export async function getCurrentModelInfo({ sessionId, channelId, appId, agentPreference, getClient, }) {
+export async function getCurrentModelInfo({ sessionId, channelId, appId, agentPreference, getClient, directory, }) {
     if (getClient instanceof Error) {
         return { type: 'none' };
     }
@@ -116,7 +117,7 @@ export async function getCurrentModelInfo({ sessionId, channelId, appId, agentPr
                 ? await getChannelAgent(channelId)
                 : undefined);
     if (effectiveAgent) {
-        const agentsResponse = await getClient().app.agents({});
+        const agentsResponse = await getClient().app.agents({ directory });
         if (agentsResponse.data) {
             const agent = agentsResponse.data.find((a) => a.name === effectiveAgent);
             if (agent?.model) {
@@ -152,7 +153,7 @@ export async function getCurrentModelInfo({ sessionId, channelId, appId, agentPr
         }
     }
     // 5. Get opencode default (config > recent > provider default)
-    const defaultModel = await getDefaultModel({ getClient });
+    const defaultModel = await getDefaultModel({ getClient, directory });
     if (defaultModel) {
         const model = `${defaultModel.providerID}/${defaultModel.modelID}`;
         return {
@@ -232,6 +233,7 @@ export async function handleModelCommand({ interaction, appId, }) {
                 channelId: targetChannelId,
                 appId: effectiveAppId,
                 getClient,
+                directory: projectDirectory,
             });
         }
         // Parallelize: fetch providers, current model info, and variant cascade at the same time.
@@ -243,6 +245,7 @@ export async function handleModelCommand({ interaction, appId, }) {
                 channelId: targetChannelId,
                 appId: effectiveAppId,
                 getClient,
+                directory: projectDirectory,
             }),
             getVariantCascade({
                 sessionId,

package/dist/commands/new-worktree.js

@@ -3,11 +3,12 @@
 // Creates thread immediately, then worktree in background so user can type
 import { ChannelType, REST, } from 'discord.js';
 import fs from 'node:fs';
-import { createPendingWorktree, setWorktreeReady, setWorktreeError, getChannelDirectory, getThreadWorktree, } from '../database.js';
+import { createPendingWorktree, setWorktreeReady, setWorktreeError, getChannelDirectory, getThreadWorktree, getThreadSession, } from '../database.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';
+import { buildExternalDirectoryPermissionRules, getOpencodeClient, initializeOpencodeForDirectory, } from '../opencode.js';
 import { WORKTREE_PREFIX } from './merge-worktree.js';
 import * as errore from 'errore';
 const logger = createLogger(LogPrefix.WORKTREE);
@@ -186,6 +187,10 @@ export async function createWorktreeInBackground({ thread, starterMessage, workt
                 threadId: thread.id,
                 worktreeDirectory: worktreeResult.directory,
             });
+            await denyPreviousCheckoutForExistingSession({
+                threadId: thread.id,
+                projectDirectory,
+            });
             // React with tree emoji to mark as worktree thread
             await reactToThread({
                 rest,
@@ -205,6 +210,41 @@ export async function createWorktreeInBackground({ thread, starterMessage, workt
         },
     });
 }
+async function denyPreviousCheckoutForExistingSession({ threadId, projectDirectory, }) {
+    const sessionId = await getThreadSession(threadId);
+    if (!sessionId) {
+        return;
+    }
+    const initializeResult = await initializeOpencodeForDirectory(projectDirectory);
+    if (initializeResult instanceof Error) {
+        logger.warn(`[WORKTREE] Failed to initialize OpenCode before denying previous checkout for thread ${threadId}: ${initializeResult.message}`);
+        return;
+    }
+    const client = getOpencodeClient(projectDirectory);
+    if (!client) {
+        logger.warn(`[WORKTREE] Missing OpenCode client for previous checkout deny update in thread ${threadId}`);
+        return;
+    }
+    const updateResult = await errore.tryAsync({
+        try: async () => {
+            await client.session.update({
+                sessionID: sessionId,
+                permission: buildExternalDirectoryPermissionRules({
+                    resolvedPattern: projectDirectory.replaceAll('\\', '/'),
+                    action: 'deny',
+                }),
+            });
+        },
+        catch: (e) => new Error('Failed to deny previous checkout for existing session', {
+            cause: e,
+        }),
+    });
+    if (updateResult instanceof Error) {
+        logger.warn(`[WORKTREE] Failed to deny previous checkout for existing session in thread ${threadId}: ${updateResult.message}`);
+        return;
+    }
+    logger.log(`[WORKTREE] Denied previous checkout for existing session ${sessionId} in thread ${threadId}`);
+}
 async function findExistingWorktreePath({ projectDirectory, worktreeName, }) {
     const listResult = await errore.tryAsync({
         try: () => execAsync('git worktree list --porcelain', { cwd: projectDirectory }),

package/dist/commands/unset-model.js

@@ -114,6 +114,7 @@ export async function handleUnsetModelCommand({ interaction, appId, }) {
             channelId: targetChannelId,
             appId,
             getClient,
+            directory: projectDirectory,
         });
         newModelText =
             newModelInfo.type === 'none'

package/dist/discord-command-registration.js

@@ -199,6 +199,18 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
         })
             .setDMPermission(false)
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('add-dir')
+            .setDescription(truncateCommandDescription('Allow the current session to access an extra directory or * for all folders'))
+            .addStringOption((option) => {
+            option
+                .setName('directory')
+                .setDescription(truncateCommandDescription('Directory to allow, resolved from the current worktree. Use * for all folders'))
+                .setRequired(true);
+            return option;
+        })
+            .setDMPermission(false)
+            .toJSON(),
         new SlashCommandBuilder()
             .setName('abort')
             .setDescription(truncateCommandDescription('Abort the current OpenCode request in this thread'))

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

@@ -274,7 +274,7 @@ describeLocal('gateway-proxy reconnection (local binary)', () => {
         if (tmpDir) {
             fs.rmSync(tmpDir, { recursive: true, force: true });
         }
-    }, 15_000);
+    }, 5_000);
     test('reconnects after local proxy restart (REST through proxy, clientId:secret)', async () => {
         tmpDir = fs.mkdtempSync(path.join(process.cwd(), 'tmp', 'gw-reconnect-'));
         proxyPort = await getAvailablePort();

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

@@ -313,11 +313,11 @@ describeIf('gateway-proxy e2e', () => {
         expect(thread).toBeDefined();
         expect(thread.id).toBeTruthy();
         firstThreadId = thread.id;
-        const reply = await discord.thread(thread.id).waitForBotReply({ timeout: 15_000 });
+        const reply = await discord.thread(thread.id).waitForBotReply({ timeout: 5_000 });
         await waitForFooterMessage({
             discord,
             threadId: thread.id,
-            timeout: 15_000,
+            timeout: 5_000,
         });
         expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
         "--- from: user (proxy-tester)
@@ -398,12 +398,14 @@ describeIf('gateway-proxy e2e', () => {
         expect(reply.content).toContain('proxy-shell-test');
     }, 15_000);
     test('second message creates separate thread', async () => {
+        const existingThreadIds = new Set((await discord.channel(CHANNEL_1_ID).getThreads()).map((thread) => {
+            return thread.id;
+        }));
         await discord.channel(CHANNEL_1_ID).user(TEST_USER_ID).sendMessage({
             content: 'second message through proxy',
         });
         const thread = await discord.channel(CHANNEL_1_ID).waitForThread({
-            predicate: (t) => (t.name?.includes('second message through proxy') ?? false) &&
-                t.id !== firstThreadId,
+            predicate: (t) => !existingThreadIds.has(t.id) && t.id !== firstThreadId,
         });
         expect(thread).toBeDefined();
         expect(thread.id).not.toBe(firstThreadId);

package/dist/interaction-handler.js

@@ -14,6 +14,7 @@ import { handleRemoveProjectCommand, handleRemoveProjectAutocomplete, } from './
 import { handleCreateNewProjectCommand } from './commands/create-new-project.js';
 import { handlePermissionButton } from './commands/permissions.js';
 import { handleAbortCommand } from './commands/abort.js';
+import { handleAddDirCommand } from './commands/add-dir.js';
 import { handleCompactCommand } from './commands/compact.js';
 import { handleShareCommand } from './commands/share.js';
 import { handleDiffCommand } from './commands/diff.js';
@@ -138,6 +139,9 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     case 'abort':
                         await handleAbortCommand({ command: interaction, appId });
                         return;
+                    case 'add-dir':
+                        await handleAddDirCommand({ command: interaction, appId });
+                        return;
                     case 'compact':
                         await handleCompactCommand({ command: interaction, appId });
                         return;

package/dist/markdown.test.js

@@ -98,7 +98,10 @@ beforeAll(async () => {
     const maxWait = 15_000;
     const pollStart = Date.now();
     while (Date.now() - pollStart < maxWait) {
-        const msgs = await client.session.messages({ sessionID });
+        const msgs = await client.session.messages({
+            sessionID,
+            directory: directories.projectDirectory,
+        });
         const assistantMsg = msgs.data?.find((m) => m.info.role === 'assistant');
         const hasTextParts = assistantMsg?.parts?.some((p) => {
             return p.type === 'text' && p.text && !p.synthetic;
@@ -114,7 +117,7 @@ beforeAll(async () => {
             setTimeout(resolve, 200);
         });
     }
-}, 60_000);
+}, 20_000);
 afterAll(async () => {
     if (directories) {
         await cleanupTestSessions({
@@ -126,7 +129,7 @@ afterAll(async () => {
     if (directories) {
         fs.rmSync(directories.dataDir, { recursive: true, force: true });
     }
-}, 10_000);
+}, 5_000);
 // Strip dynamic parts (timestamps, durations, branch names) for stable assertions
 function normalizeMarkdown(md) {
     return md

package/dist/message-finish-field.e2e.test.js

@@ -99,14 +99,14 @@ beforeAll(async () => {
         throw getClient;
     }
     client = getClient();
-}, 60_000);
+}, 20_000);
 afterAll(async () => {
     await cleanupTestSessions({
         projectDirectory: directories.projectDirectory,
         testStartTime,
     });
     await stopOpencodeServer();
-}, 10_000);
+}, 5_000);
 test('tool-call step has finish="tool-calls", follow-up has finish="stop"', async () => {
     const session = await client.session.create({
         directory: directories.projectDirectory,
@@ -123,7 +123,10 @@ test('tool-call step has finish="tool-calls", follow-up has finish="stop"', asyn
     const pollStart = Date.now();
     let completedAssistants = [];
     while (Date.now() - pollStart < maxWait) {
-        const msgs = await client.session.messages({ sessionID });
+        const msgs = await client.session.messages({
+            sessionID,
+            directory: directories.projectDirectory,
+        });
         completedAssistants = (msgs.data || [])
             .filter((m) => {
             return m.info.role === 'assistant' && m.info.time.completed;
@@ -162,4 +165,4 @@ test('tool-call step has finish="tool-calls", follow-up has finish="stop"', asyn
   `);
     const finishes = completedAssistants.map((m) => { return m.finish; });
     expect(finishes).toEqual(['tool-calls', 'stop']);
-}, 15_000);
+}, 5_000);

package/dist/message-preprocessing.js

@@ -19,12 +19,12 @@ const logger = createLogger(LogPrefix.SESSION);
 const voiceLogger = createLogger(LogPrefix.VOICE);
 export const VOICE_MESSAGE_TRANSCRIPTION_PREFIX = 'Voice message transcription from Discord user:\n';
 /** Fetch available agents from OpenCode for voice transcription agent selection. */
-async function fetchAvailableAgents(getClient) {
+async function fetchAvailableAgents(getClient, directory) {
     if (getClient instanceof Error) {
         return [];
     }
     const result = await errore.tryAsync(() => {
-        return getClient().app.agents({});
+        return getClient().app.agents({ directory });
     });
     if (result instanceof Error) {
         return [];
@@ -138,7 +138,7 @@ export async function preprocessExistingThreadMessage({ message, thread, project
                     client,
                     excludeSessionId: sessionId,
                 }),
-                fetchAvailableAgents(getClient),
+                fetchAvailableAgents(getClient, projectDirectory),
             ]);
             if (errore.isOk(sessionContextResult)) {
                 currentSessionContext = sessionContextResult;
@@ -216,7 +216,7 @@ export async function preprocessNewSessionMessage({ message, thread, projectDire
     if (hasVoiceAttachment && projectDirectory) {
         try {
             const getClient = await initializeOpencodeForDirectory(projectDirectory);
-            agents = await fetchAvailableAgents(getClient);
+            agents = await fetchAvailableAgents(getClient, projectDirectory);
         }
         catch (e) {
             voiceLogger.error(`Could not fetch agents for voice transcription:`, e);
@@ -281,7 +281,7 @@ export async function preprocessNewThreadMessage({ message, thread, projectDirec
     if (hasVoiceAttachment && projectDirectory) {
         try {
             const getClient = await initializeOpencodeForDirectory(projectDirectory);
-            agents = await fetchAvailableAgents(getClient);
+            agents = await fetchAvailableAgents(getClient, projectDirectory);
         }
         catch (e) {
             voiceLogger.error(`Could not fetch agents for voice transcription:`, e);