kimaki 0.4.76 → 0.4.78

package/dist/queue-advanced-model-switch.e2e.test.js

@@ -0,0 +1,299 @@
+// E2e test for /model switch behavior through interrupt recovery.
+// Reproduces fallback where interrupt plugin resume can run without model,
+// causing default opencode.json model to be used after switching session model.
+import { describe, test, expect } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
+import { waitForBotMessageContaining, waitForBotReplyAfterUserMessage, waitForFooterMessage, waitForMessageById, } from './test-utils.js';
+import { getThreadState } from './session-handler/thread-runtime-state.js';
+import { getSessionModel } from './database.js';
+import { initializeOpencodeForDirectory } from './opencode.js';
+const TEXT_CHANNEL_ID = '200000000000001007';
+function getCustomIdFromInteractionData({ serializedComponents, prefix, }) {
+    const escapedPrefix = prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const customIdRegex = new RegExp(`\"custom_id\"\\s*:\\s*\"(${escapedPrefix}[^\"]+)\"`);
+    const match = serializedComponents.match(customIdRegex);
+    if (!match?.[1]) {
+        throw new Error(`Could not find custom_id with prefix ${prefix} in components: ${serializedComponents}`);
+    }
+    return match[1];
+}
+async function waitForMessageComponentsWithCustomId({ discord, threadId, messageId, customIdPrefix, timeoutMs, }) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const message = await waitForMessageById({
+            discord,
+            threadId,
+            messageId,
+            timeout: 1_000,
+        });
+        const serializedComponents = JSON.stringify(message.components);
+        if (serializedComponents.includes(customIdPrefix)) {
+            return serializedComponents;
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, 50);
+        });
+    }
+    throw new Error(`Timed out waiting for custom_id prefix ${customIdPrefix} in message ${messageId}`);
+}
+async function waitForInteractionMessage({ getInteraction, interactionId, timeoutMs, }) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const response = await getInteraction(interactionId);
+        if (response?.messageId) {
+            return {
+                messageId: response.messageId,
+                data: response.data || '',
+            };
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, 50);
+        });
+    }
+    throw new Error(`Timed out waiting for interaction message ${interactionId}`);
+}
+describe('queue advanced: /model with interrupt recovery', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-model-switch-e2e',
+        dirName: 'qa-model-switch-e2e',
+        username: 'queue-model-switch-tester',
+    });
+    test('session model selected in /model survives interrupt-plugin resume path', async () => {
+        const buildAgentDir = path.join(ctx.directories.projectDirectory, '.opencode', 'agent');
+        fs.mkdirSync(buildAgentDir, { recursive: true });
+        fs.writeFileSync(path.join(buildAgentDir, 'build.md'), [
+            '---',
+            'name: build',
+            'description: Default build agent for deterministic model tests',
+            'model: deterministic-provider/deterministic-v2',
+            '---',
+            '',
+            'You are the default build agent.',
+            '',
+        ].join('\n'));
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: model-switcher-setup',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: model-switcher-setup';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        await th.waitForBotReply({ timeout: 4_000 });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 4_000,
+        });
+        const modelCommand = await th.user(TEST_USER_ID).runSlashCommand({
+            name: 'model',
+        });
+        await th.waitForInteractionAck({
+            interactionId: modelCommand.id,
+            timeout: 4_000,
+        });
+        const providerStep = await waitForInteractionMessage({
+            getInteraction: (interactionId) => {
+                return th.getInteractionResponse(interactionId);
+            },
+            interactionId: modelCommand.id,
+            timeoutMs: 4_000,
+        });
+        const providerCustomId = getCustomIdFromInteractionData({
+            serializedComponents: await waitForMessageComponentsWithCustomId({
+                discord: ctx.discord,
+                threadId: thread.id,
+                messageId: providerStep.messageId,
+                customIdPrefix: 'model_provider:',
+                timeoutMs: 4_000,
+            }),
+            prefix: 'model_provider:',
+        });
+        const providerSelect = await th.user(TEST_USER_ID).selectMenu({
+            messageId: providerStep.messageId,
+            customId: providerCustomId,
+            values: ['deterministic-provider'],
+        });
+        await th.waitForInteractionAck({
+            interactionId: providerSelect.id,
+            timeout: 4_000,
+        });
+        const modelStep = await waitForInteractionMessage({
+            getInteraction: (interactionId) => {
+                return th.getInteractionResponse(interactionId);
+            },
+            interactionId: providerSelect.id,
+            timeoutMs: 4_000,
+        });
+        const modelCustomId = getCustomIdFromInteractionData({
+            serializedComponents: await waitForMessageComponentsWithCustomId({
+                discord: ctx.discord,
+                threadId: thread.id,
+                messageId: modelStep.messageId,
+                customIdPrefix: 'model_select:',
+                timeoutMs: 4_000,
+            }),
+            prefix: 'model_select:',
+        });
+        const modelSelect = await th.user(TEST_USER_ID).selectMenu({
+            messageId: modelStep.messageId,
+            customId: modelCustomId,
+            values: ['deterministic-v3'],
+        });
+        await th.waitForInteractionAck({
+            interactionId: modelSelect.id,
+            timeout: 4_000,
+        });
+        const maybeVariantOrScopeStep = await waitForInteractionMessage({
+            getInteraction: (interactionId) => {
+                return th.getInteractionResponse(interactionId);
+            },
+            interactionId: modelSelect.id,
+            timeoutMs: 4_000,
+        });
+        const maybeVariantOrScopeMessage = await waitForMessageById({
+            discord: ctx.discord,
+            threadId: thread.id,
+            messageId: maybeVariantOrScopeStep.messageId,
+            timeout: 4_000,
+        });
+        const maybeVariantOrScopeComponents = JSON.stringify(maybeVariantOrScopeMessage.components);
+        const scopeStep = maybeVariantOrScopeComponents.includes('model_variant:')
+            ? await (async () => {
+                const variantCustomId = getCustomIdFromInteractionData({
+                    serializedComponents: maybeVariantOrScopeComponents,
+                    prefix: 'model_variant:',
+                });
+                const variantSelect = await th.user(TEST_USER_ID).selectMenu({
+                    messageId: maybeVariantOrScopeStep.messageId,
+                    customId: variantCustomId,
+                    values: ['__none__'],
+                });
+                await th.waitForInteractionAck({
+                    interactionId: variantSelect.id,
+                    timeout: 4_000,
+                });
+                return waitForInteractionMessage({
+                    getInteraction: (interactionId) => {
+                        return th.getInteractionResponse(interactionId);
+                    },
+                    interactionId: variantSelect.id,
+                    timeoutMs: 4_000,
+                });
+            })()
+            : maybeVariantOrScopeStep;
+        const scopeCustomId = getCustomIdFromInteractionData({
+            serializedComponents: await waitForMessageComponentsWithCustomId({
+                discord: ctx.discord,
+                threadId: thread.id,
+                messageId: scopeStep.messageId,
+                customIdPrefix: 'model_scope:',
+                timeoutMs: 4_000,
+            }),
+            prefix: 'model_scope:',
+        });
+        const scopeSelect = await th.user(TEST_USER_ID).selectMenu({
+            messageId: scopeStep.messageId,
+            customId: scopeCustomId,
+            values: ['session'],
+        });
+        await th.waitForInteractionAck({
+            interactionId: scopeSelect.id,
+            timeout: 4_000,
+        });
+        const sessionId = getThreadState(thread.id)?.sessionId;
+        expect(sessionId).toBeDefined();
+        if (!sessionId) {
+            throw new Error('Expected session id to be present after /model selection');
+        }
+        const sessionModel = await getSessionModel(sessionId);
+        expect(sessionModel?.modelId).toBe('deterministic-provider/deterministic-v3');
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'starting sleep',
+            afterUserMessageIncludes: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+            timeout: 4_000,
+        });
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: model-switcher-followup',
+        });
+        await waitForBotReplyAfterUserMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            userMessageIncludes: 'model-switcher-followup',
+            timeout: 8_000,
+        });
+        const finalMessages = await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 8_000,
+            afterMessageIncludes: 'model-switcher-followup',
+            afterAuthorId: TEST_USER_ID,
+        });
+        const footer = [...finalMessages].reverse().find((message) => {
+            return message.author.id === ctx.discord.botUserId
+                && message.content.startsWith('*')
+                && message.content.includes('⋅');
+        });
+        expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (queue-model-switch-tester)
+        Reply with exactly: model-switcher-setup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        Model set for this session:
+        **Deterministic Provider** / **deterministic-v3**
+        \`deterministic-provider/deterministic-v3\`
+        _Restarting current request with new model..._
+        _Tip: create [agent .md files](https://github.com/remorses/kimaki/blob/main/docs/model-switching.md) in .opencode/agent/ for one-command model switching_
+        --- from: user (queue-model-switch-tester)
+        PLUGIN_TIMEOUT_SLEEP_MARKER
+        --- from: assistant (TestBot)
+        ⬥ ok
+        ⬥ starting sleep 100
+        --- from: user (queue-model-switch-tester)
+        Reply with exactly: model-switcher-followup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v3*"
+      `);
+        expect(footer).toBeDefined();
+        expect(footer?.content).toContain('deterministic-v3');
+        const getClient = await initializeOpencodeForDirectory(ctx.directories.projectDirectory);
+        if (getClient instanceof Error) {
+            throw getClient;
+        }
+        const sessionMessagesResponse = await getClient().session.messages({
+            sessionID: sessionId,
+            directory: ctx.directories.projectDirectory,
+        });
+        const sessionMessages = sessionMessagesResponse.data || [];
+        const emptyUserMessagesWithDefaultModel = sessionMessages.filter((message) => {
+            if (message.info.role !== 'user') {
+                return false;
+            }
+            const hasNonEmptyTextPart = message.parts.some((part) => {
+                if (part.type !== 'text') {
+                    return false;
+                }
+                return part.text.trim().length > 0;
+            });
+            if (hasNonEmptyTextPart) {
+                return false;
+            }
+            return message.info.model.modelID === 'deterministic-v2';
+        });
+        expect(emptyUserMessagesWithDefaultModel.length).toBe(0);
+    }, 20_000);
+});

package/dist/queue-advanced-permissions-typing.e2e.test.js

@@ -1,7 +1,7 @@
 // E2e tests for typing indicator behavior around permission prompts.
 import { describe, test, expect } from 'vitest';
 import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
-import { waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
+import { waitForBotMessageContaining, waitForBotReplyAfterUserMessage, waitForFooterMessage, } from './test-utils.js';
 import { pendingPermissions } from './session-handler/thread-session-runtime.js';
 const TEXT_CHANNEL_ID = '200000000000001005';
 async function waitForPendingPermission({ threadId, timeoutMs, }) {
@@ -103,4 +103,76 @@ describe('queue advanced: typing around permissions', () => {
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
     }, 20_000);
+    test('manual thread message dismisses pending permission and sends the new prompt', async () => {
+        const initialPrompt = 'PERMISSION_TYPING_MARKER dismiss-flow';
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: initialPrompt,
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === initialPrompt;
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        await waitForPendingPermission({
+            threadId: thread.id,
+            timeoutMs: 4_000,
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'Permission Required',
+            timeout: 4_000,
+        });
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: post-permission-user-message',
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: 'Permission dismissed - user sent a new message.',
+            timeout: 4_000,
+        });
+        await waitForBotReplyAfterUserMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            userMessageIncludes: 'post-permission-user-message',
+            timeout: 4_000,
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'ok',
+            afterUserMessageIncludes: 'post-permission-user-message',
+            timeout: 4_000,
+        });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: ctx.discord.botUserId,
+        });
+        const timeline = await th.text({ showInteractions: true });
+        const normalizedTimeline = timeline.replace('⬥ requesting external read permission\n', '');
+        expect(normalizedTimeline).toMatchInlineSnapshot(`
+        "--- from: user (queue-permission-tester)
+        PERMISSION_TYPING_MARKER dismiss-flow
+        --- from: assistant (TestBot)
+        ⚠️ **Permission Required**
+        **Type:** \`external_directory\`
+        Agent is accessing files outside the project. [Learn more](https://opencode.ai/docs/permissions/#external-directories)
+        **Pattern:** \`/Users/morse/*\`
+        _Permission dismissed - user sent a new message._
+        --- from: user (queue-permission-tester)
+        Reply with exactly: post-permission-user-message
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `);
+    }, 20_000);
 });

package/dist/runtime-lifecycle.e2e.test.js

@@ -6,7 +6,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';
@@ -20,7 +19,7 @@ import { getRuntime } from './session-handler/thread-session-runtime.js';
 import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChannelVerbosity, } from './database.js';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { initializeOpencodeForDirectory, restartOpencodeServer, stopOpencodeServer, } from './opencode.js';
-import { cleanupTestSessions, waitForBotMessageContaining, waitForBotReplyAfterUserMessage, } from './test-utils.js';
+import { chooseLockPort, cleanupTestSessions, waitForBotMessageContaining, waitForBotReplyAfterUserMessage, } from './test-utils.js';
 const TEST_USER_ID = '200000000000000888';
 const TEXT_CHANNEL_ID = '200000000000000889';
 function createRunDirectories() {
@@ -31,23 +30,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: [
@@ -127,7 +109,7 @@ describe('runtime lifecycle', () => {
     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/session-handler/event-stream-state.js

@@ -71,6 +71,11 @@ export function isAssistantMessageNaturalCompletion({ message, }) {
     if (message.error) {
         return false;
     }
+    // finish="tool-calls" means the model's last step was tool execution.
+    // Mid-turn tool-call steps don't get footers — the footer comes from the
+    // final text response (finish="stop") that follows. If the turn ends with
+    // only tool-calls and no text follow-up, no footer is emitted. This is
+    // acceptable since models almost always follow up with text after tools.
     return message.finish !== 'tool-calls';
 }
 export function hasAssistantMessageCompletedBefore({ events, sessionId, messageId, upToIndex, }) {

package/dist/session-handler/event-stream-state.test.js

@@ -346,7 +346,7 @@ describe('real-session-task-user-interruption', () => {
     const childSessionId = 'ses_3464f3a1dffeBBD0d15EqnGjAh';
     const firstAssistantId = 'msg_cb9b0ba96001SpPjgzxWPmRuW9';
     const secondAssistantId = 'msg_cb9b1ae5c001E5G3Ql6aXNpst2';
-    test('tool-call handoff assistant is not terminal but the resumed reply is', () => {
+    test('tool-call handoff assistant is not a natural completion but the resumed reply is', () => {
         const firstAssistant = getAssistantMessageById({
             events,
             sessionId,
@@ -357,6 +357,8 @@ describe('real-session-task-user-interruption', () => {
             sessionId,
             messageId: secondAssistantId,
         });
+        // The first message finished with tool-calls — not a natural completion
+        // (footer is deferred to session.idle). The second message IS natural.
         expect(isAssistantMessageNaturalCompletion({ message: firstAssistant })).toBe(false);
         expect(isAssistantMessageNaturalCompletion({ message: secondAssistant })).toBe(true);
     });
@@ -482,7 +484,7 @@ describe('real-session-action-buttons', () => {
     const sessionId = getSessionId(events);
     const toolCallAssistantId = 'msg_cb9b55c3b001hXC9qxjVxLMypM';
     const finalAssistantId = 'msg_cb9b5ddd1001FALqKNM6xW98u6';
-    test('tool-call handoff assistant is not terminal but final reply is', () => {
+    test('tool-call handoff assistant is not a natural completion but final reply is', () => {
         const toolCallAssistant = getAssistantMessageById({
             events,
             sessionId,
@@ -493,6 +495,8 @@ describe('real-session-action-buttons', () => {
             sessionId,
             messageId: finalAssistantId,
         });
+        // The tool-call message has finish="tool-calls" — not a natural completion
+        // (footer is deferred to session.idle). The final text message IS natural.
         expect(isAssistantMessageNaturalCompletion({ message: toolCallAssistant })).toBe(false);
         expect(isAssistantMessageNaturalCompletion({ message: finalAssistant })).toBe(true);
     });

package/dist/session-handler/thread-session-runtime.js

@@ -62,7 +62,10 @@ export function getOrCreateRuntime(opts) {
         // Reconcile sdkDirectory: worktree threads transition from pending
         // (projectDirectory) to ready (worktree path) after runtime creation.
         if (existing.sdkDirectory !== opts.sdkDirectory) {
-            existing.sdkDirectory = opts.sdkDirectory;
+            existing.handleDirectoryChanged({
+                oldDirectory: existing.sdkDirectory,
+                newDirectory: opts.sdkDirectory,
+            });
         }
         return existing;
     }
@@ -524,6 +527,33 @@ export class ThreadSessionRuntime {
         // action buttons, file uploads, html actions).
         cleanupPendingUiForThread(this.thread.id);
     }
+    // Called when sdkDirectory changes (e.g. worktree becomes ready after
+    // /new-worktree in an existing thread). The event listener was subscribed
+    // to the old directory's Instance in opencode — events from the new
+    // directory's Instance won't reach it. We must reconnect the listener
+    // and clear the old session so ensureSession creates a fresh one under
+    // the new Instance.
+    handleDirectoryChanged({ oldDirectory, newDirectory, }) {
+        logger.log(`[LISTENER] sdkDirectory changed for thread ${this.threadId}: ${oldDirectory} → ${newDirectory}`);
+        this.sdkDirectory = newDirectory;
+        // Clear cached session — it was created under the old directory's
+        // opencode Instance and can't be reused from the new one.
+        threadState.updateThread(this.threadId, (t) => ({
+            ...t,
+            sessionId: undefined,
+        }));
+        // Restart event listener to subscribe under the new directory.
+        const currentController = this.state?.listenerController;
+        if (currentController) {
+            currentController.abort(new Error('sdkDirectory changed'));
+            threadState.updateThread(this.threadId, (t) => ({
+                ...t,
+                listenerController: new AbortController(),
+            }));
+            this.listenerLoopRunning = false;
+            void this.startEventListener();
+        }
+    }
     handleSharedServerStarted({ port, }) {
         const currentController = this.state?.listenerController;
         if (!currentController) {
@@ -2656,7 +2686,7 @@ export class ThreadSessionRuntime {
         let contextInfo = '';
         const folderName = path.basename(this.sdkDirectory);
         const client = getOpencodeClient(this.projectDirectory);
-        // Run git branch, token fetch, and provider list in parallel
+        // Run git branch and token fetch in parallel (fast, no external CLI)
         const [branchResult, contextResult] = await Promise.all([
             errore.tryAsync(() => {
                 return execAsync('git symbolic-ref --short HEAD', {