kimaki 0.26.0 → 0.28.0

package/dist/question-abort-clears-dropdown.e2e.test.js

@@ -0,0 +1,89 @@
+// E2e test: aborting a run must kill the pending question dropdown.
+// Questions have no TTL, so abort is the only thing that clears them while the
+// thread stays alive. Without this, a stale dropdown keeps accepting clicks and
+// answers a question whose run is already dead.
+import { describe, test, expect } from 'vitest';
+import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
+import { waitForBotMessageContaining } from './test-utils.js';
+import { pendingQuestionContexts } from './commands/ask-question.js';
+import { getRuntime } from './session-handler/thread-session-runtime.js';
+const TEXT_CHANNEL_ID = '200000000000001031';
+describe('abort clears pending question dropdown', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-question-abort',
+        dirName: 'qa-question-abort',
+        username: 'question-abort-tester',
+    });
+    test('dropdown stops accepting answers after abort', async () => {
+        const marker = 'QUESTION_SELECT_QUEUE_MARKER abort-test';
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: marker,
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 8_000,
+            predicate: (t) => {
+                return t.name === marker;
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        const questionMessages = await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: 'How to proceed?',
+            timeout: 12_000,
+        });
+        const questionMsg = questionMessages.find((message) => {
+            return message.content.includes('How to proceed?');
+        });
+        if (!questionMsg) {
+            throw new Error('Expected question message');
+        }
+        const pendingEntry = [...pendingQuestionContexts.entries()].find(([, context]) => {
+            return context.thread.id === thread.id;
+        });
+        if (!pendingEntry) {
+            throw new Error('Expected pending question context');
+        }
+        const contextHash = pendingEntry[0];
+        const runtime = getRuntime(thread.id);
+        if (!runtime) {
+            throw new Error('Expected runtime for question abort test');
+        }
+        runtime.abortActiveRun('test-question-abort');
+        // Click the now-dead dropdown. The answer echo must never appear.
+        const interaction = await th.user(TEST_USER_ID).selectMenu({
+            messageId: questionMsg.id,
+            customId: `ask_question:${contextHash}:0`,
+            values: ['0'],
+        });
+        await th.waitForInteractionAck({
+            interactionId: interaction.id,
+            timeout: 8_000,
+        });
+        for (let i = 0; i < 10; i++) {
+            const messages = await th.getMessages();
+            const answered = messages.find((message) => {
+                return message.content.includes('» **question-abort-tester:** Alpha');
+            });
+            if (answered) {
+                throw new Error('Dropdown was still answerable after abort');
+            }
+            await new Promise((resolve) => {
+                setTimeout(resolve, 20);
+            });
+        }
+        const timeline = await th.text({ showInteractions: true });
+        expect(timeline).toMatchInlineSnapshot(`
+        "--- from: user (question-abort-tester)
+        QUESTION_SELECT_QUEUE_MARKER abort-test
+        --- from: assistant (TestBot)
+        > *using deterministic-provider/deterministic-v2*
+        **Select action**
+        How to proceed?
+        [user selects dropdown: 0]
+        This question has expired. Please ask the AI again."
+      `);
+        expect(pendingQuestionContexts.size).toBe(0);
+    }, 20_000);
+});

package/dist/question-abort-retry-text-before-dropdown.e2e.test.js

@@ -0,0 +1,150 @@
+// E2e: leftover aborted text must post before a later question dropdown.
+// Abort leaves an open text part buffered under the first assistant message.
+// The retry is a new user turn, so a single-id / current-turn flush misses it.
+import { describe, test, expect } from 'vitest';
+import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
+import { getRuntime } from './session-handler/thread-session-runtime.js';
+import { getMessageVisibleText, waitForBotMessageContaining } from './test-utils.js';
+const TEXT_CHANNEL_ID = '200000000000001043';
+function createAbortRetryQuestionMatchers() {
+    const leftoverOpenTextMatcher = {
+        id: 'abort-retry-leftover-open-text',
+        priority: 130,
+        when: {
+            lastMessageRole: 'user',
+            latestUserTextIncludes: 'ABORT_RETRY_LEFTOVER_TEXT_MARKER',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'abort-retry-started' },
+                {
+                    type: 'text-delta',
+                    id: 'abort-retry-started',
+                    delta: 'abort-retry-started',
+                },
+                { type: 'text-end', id: 'abort-retry-started' },
+                { type: 'text-start', id: 'abort-retry-leftover' },
+                {
+                    type: 'text-delta',
+                    id: 'abort-retry-leftover',
+                    delta: 'LEFTOVER_ABORTED_TEXT',
+                },
+                {
+                    type: 'finish',
+                    finishReason: 'stop',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+            partDelaysMs: [0, 0, 0, 0, 0, 0, 100_000],
+        },
+    };
+    const questionAfterAbortMatcher = {
+        id: 'question-after-abort-retry',
+        priority: 131,
+        when: {
+            lastMessageRole: 'user',
+            latestUserTextIncludes: 'QUESTION_AFTER_ABORT_RETRY_MARKER',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'plan-after-abort' },
+                {
+                    type: 'text-delta',
+                    id: 'plan-after-abort',
+                    delta: 'PLAN_AFTER_ABORT_RETRY',
+                },
+                {
+                    type: 'tool-call',
+                    toolCallId: 'question-after-abort-call',
+                    toolName: 'question',
+                    input: JSON.stringify({
+                        questions: [{
+                                question: 'What next after abort?',
+                                header: 'Next step',
+                                options: [
+                                    { label: 'Commit', description: 'Commit these files' },
+                                    { label: 'Stop', description: 'Leave uncommitted' },
+                                ],
+                            }],
+                    }),
+                },
+                { type: 'text-end', id: 'plan-after-abort' },
+                {
+                    type: 'finish',
+                    finishReason: 'tool-calls',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+            partDelaysMs: [200, 0, 0, 0, 400, 0],
+        },
+    };
+    return [leftoverOpenTextMatcher, questionAfterAbortMatcher];
+}
+describe('question text before dropdown after abort retry', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-question-abort-retry-order',
+        dirName: 'qa-question-abort-retry-order',
+        username: 'question-abort-retry-tester',
+        extraMatchers: createAbortRetryQuestionMatchers(),
+    });
+    test('posts leftover aborted text before the question dropdown', async () => {
+        const leftoverMarker = 'ABORT_RETRY_LEFTOVER_TEXT_MARKER';
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: leftoverMarker,
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 8_000,
+            predicate: (t) => {
+                return t.name === leftoverMarker;
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: 'abort-retry-started',
+            timeout: 8_000,
+        });
+        const runtime = getRuntime(thread.id);
+        expect(runtime).toBeDefined();
+        if (!runtime) {
+            throw new Error('Expected runtime for abort-retry question test');
+        }
+        runtime.abortActiveRun('test-question-abort-retry-flush');
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'QUESTION_AFTER_ABORT_RETRY_MARKER',
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: 'What next after abort?',
+            timeout: 8_000,
+        });
+        expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (question-abort-retry-tester)
+        ABORT_RETRY_LEFTOVER_TEXT_MARKER
+        --- from: assistant (TestBot)
+        > *using deterministic-provider/deterministic-v2*
+        > abort-retry-started
+        --- from: user (question-abort-retry-tester)
+        QUESTION_AFTER_ABORT_RETRY_MARKER
+        --- from: assistant (TestBot)
+        > LEFTOVER_ABORTED_TEXT
+        PLAN_AFTER_ABORT_RETRY
+        **Next step**
+        What next after abort?"
+      `);
+        const messages = await th.getMessages();
+        const leftoverIndex = messages.findIndex((message) => {
+            return getMessageVisibleText(message).includes('LEFTOVER_ABORTED_TEXT');
+        });
+        const questionIndex = messages.findIndex((message) => {
+            return getMessageVisibleText(message).includes('What next after abort?');
+        });
+        expect(leftoverIndex).toBeGreaterThanOrEqual(0);
+        expect(questionIndex).toBeGreaterThan(leftoverIndex);
+    }, 15_000);
+});

package/dist/question-text-before-dropdown.e2e.test.js

@@ -0,0 +1,52 @@
+// E2e: text that precedes a question tool must post before the dropdown.
+// OpenCode can emit question.asked before the text part's time.end; Kimaki
+// must wait so the plan is not hidden under the question UI.
+import { describe, test, expect } from 'vitest';
+import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
+import { getMessageVisibleText, waitForBotMessageContaining } from './test-utils.js';
+const TEXT_CHANNEL_ID = '200000000000001042';
+describe('question text before dropdown', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-question-text-order',
+        dirName: 'qa-question-text-order',
+        username: 'question-text-tester',
+    });
+    test('posts plan text before the question dropdown', async () => {
+        const marker = 'QUESTION_AFTER_TEXT_MARKER';
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: marker,
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 8_000,
+            predicate: (t) => {
+                return t.name === marker;
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: 'What next?',
+            timeout: 8_000,
+        });
+        expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (question-text-tester)
+        QUESTION_AFTER_TEXT_MARKER
+        --- from: assistant (TestBot)
+        > *using deterministic-provider/deterministic-v2*
+        PLAN_TEXT_BEFORE_QUESTION
+        **Next step**
+        What next?"
+      `);
+        const messages = await th.getMessages();
+        const planIndex = messages.findIndex((message) => {
+            return getMessageVisibleText(message).includes('PLAN_TEXT_BEFORE_QUESTION');
+        });
+        const questionIndex = messages.findIndex((message) => {
+            return getMessageVisibleText(message).includes('What next?');
+        });
+        expect(planIndex).toBeGreaterThanOrEqual(0);
+        expect(questionIndex).toBeGreaterThan(planIndex);
+    }, 15_000);
+});

package/dist/queue-advanced-abort.e2e.test.js

@@ -5,7 +5,7 @@ import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-set
 import { getRuntime, } from './session-handler/thread-session-runtime.js';
 import { getThreadState } from './session-handler/thread-runtime-state.js';
 import { setSessionModel } from './database.js';
-import { waitForFooterMessage, waitForBotMessageContaining, waitForBotReplyAfterUserMessage, } from './test-utils.js';
+import { isFooterMessage, waitForFooterMessage, waitForBotMessageContaining, waitForBotReplyAfterUserMessage, } from './test-utils.js';
 const TEXT_CHANNEL_ID = '200000000000001003';
 const e2eTest = describe;
 e2eTest('queue advanced: abort and retry', () => {
@@ -83,7 +83,7 @@ e2eTest('queue advanced: abort and retry', () => {
         const timeline = await th.text();
         expect(timeline).toContain('Reply with exactly: oscar');
         expect(timeline).toContain('PLUGIN_TIMEOUT_SLEEP_MARKER');
-        expect(timeline).toContain('⬥ starting sleep 100');
+        expect(timeline).toContain('starting sleep 100');
         expect(timeline).toContain('Reply with exactly: papa');
         expect(timeline).toContain('*project ⋅ main ⋅');
         // oscar comes before the sleep marker, sleep before papa
@@ -145,9 +145,7 @@ e2eTest('queue advanced: abort and retry', () => {
             const msgs = await th.getMessages();
             const newMsgs = msgs.slice(baselineCount);
             const hasFooter = newMsgs.some((m) => {
-                return m.author.id === ctx.discord.botUserId
-                    && m.content.startsWith('*')
-                    && m.content.includes('⋅');
+                return isFooterMessage({ message: m, botUserId: ctx.discord.botUserId });
             });
             expect(hasFooter).toBe(false);
         }
@@ -155,9 +153,9 @@ e2eTest('queue advanced: abort and retry', () => {
         "--- from: user (queue-advanced-tester)
         Reply with exactly: abort-no-footer-setup
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>
         --- from: user (queue-advanced-tester)
         SLOW_ABORT_MARKER run long response"
       `);
@@ -256,7 +254,7 @@ e2eTest('queue advanced: abort and retry', () => {
         const text = await th.text();
         // The follow-up reply ("ok") must be present with deterministic-v3
         expect(text).toContain('Reply with exactly: model-switch-followup');
-        expect(text).toContain('⬥ ok');
+        expect(text).toContain('ok');
         // The old sleep text should be visible from the first turn
         expect(text).toContain('starting sleep 100');
     }, 10_000);
@@ -286,7 +284,7 @@ e2eTest('queue advanced: abort and retry', () => {
         "--- from: user (queue-advanced-tester)
         Reply with exactly: force-abort-setup
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
         --- from: user (queue-advanced-tester)
         SLOW_ABORT_MARKER run long response"
       `);

package/dist/queue-advanced-action-buttons.e2e.test.js

@@ -122,15 +122,15 @@ describe('queue advanced: action buttons', () => {
         "--- from: user (queue-action-tester)
         Reply with exactly: action-button-setup
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>
         **Action Required**
         _Selected: Continue action-buttons flow_
         [user clicks button]
         » **queue-action-tester:** Continue action-buttons flow
-        ⬥ action-buttons-click-continued
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > action-buttons-click-continued
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
       `);
         expect(timeline).toContain('action-buttons-click-continued');
     }, 20_000);
@@ -195,9 +195,9 @@ describe('queue advanced: action buttons', () => {
         "--- from: user (queue-action-tester)
         Reply with exactly: action-button-dismiss-setup
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>
         **Action Required**
         _Buttons dismissed._
         --- from: user (queue-action-tester)

package/dist/queue-advanced-e2e-setup.js

@@ -78,6 +78,31 @@ export function createDeterministicMatchers() {
             partDelaysMs: [0, 500, 0, 0, 0],
         },
     };
+    const questionSelectDrainMatcher = {
+        id: 'question-select-drain-first',
+        priority: 109,
+        when: {
+            latestUserTextIncludes: 'QUESTION_SELECT_DRAIN_FIRST_MARKER',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'question-select-drain-first' },
+                {
+                    type: 'text-delta',
+                    id: 'question-select-drain-first',
+                    delta: 'question-drain-first',
+                },
+                { type: 'text-end', id: 'question-select-drain-first' },
+                {
+                    type: 'finish',
+                    finishReason: 'stop',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+            partDelaysMs: [0, 0, 0, 400, 0],
+        },
+    };
     const slowAbortMatcher = {
         id: 'slow-abort-marker',
         priority: 100,
@@ -260,9 +285,7 @@ export function createDeterministicMatchers() {
                     usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
                 },
             ],
-            // Keep run busy long enough after permission reply so typing keepalive
-            // must pulse again. This makes typing resume assertions deterministic.
-            partDelaysMs: [0, 0, 0, 0, 8_000],
+            partDelaysMs: [0, 400, 0, 0, 0],
         },
     };
     const externalDirectoryProbeMatcher = {
@@ -382,6 +405,7 @@ export function createDeterministicMatchers() {
         when: {
             lastMessageRole: 'user',
             latestUserTextIncludes: 'QUESTION_TEXT_ANSWER_MARKER',
+            rawPromptRegex: '^(?!.*question-text-answer-call)',
         },
         then: {
             parts: [
@@ -417,6 +441,7 @@ export function createDeterministicMatchers() {
         when: {
             lastMessageRole: 'user',
             latestUserTextIncludes: 'QUESTION_SELECT_QUEUE_MARKER',
+            rawPromptRegex: '^(?!.*question-select-queue-call)',
         },
         then: {
             parts: [
@@ -444,6 +469,49 @@ export function createDeterministicMatchers() {
             ],
         },
     };
+    // Text then question, with text-end delayed after the tool call.
+    // Reproduces OpenCode emitting question.asked before the text part's time.end.
+    const questionAfterTextMatcher = {
+        id: 'question-after-text-marker',
+        priority: 108,
+        when: {
+            lastMessageRole: 'user',
+            latestUserTextIncludes: 'QUESTION_AFTER_TEXT_MARKER',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'plan-before-question' },
+                {
+                    type: 'text-delta',
+                    id: 'plan-before-question',
+                    delta: 'PLAN_TEXT_BEFORE_QUESTION',
+                },
+                {
+                    type: 'tool-call',
+                    toolCallId: 'question-after-text-call',
+                    toolName: 'question',
+                    input: JSON.stringify({
+                        questions: [{
+                                question: 'What next?',
+                                header: 'Next step',
+                                options: [
+                                    { label: 'Commit', description: 'Commit these files' },
+                                    { label: 'Stop', description: 'Leave uncommitted' },
+                                ],
+                            }],
+                    }),
+                },
+                { type: 'text-end', id: 'plan-before-question' },
+                {
+                    type: 'finish',
+                    finishReason: 'tool-calls',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+            partDelaysMs: [200, 0, 0, 0, 400, 0],
+        },
+    };
     // Model responds with text + tool call, then after tool result the
     // follow-up matcher responds with text. This creates two assistant messages:
     // first with finish="tool-calls" + completed, second with finish="stop".
@@ -753,6 +821,7 @@ export function createDeterministicMatchers() {
         },
     };
     return [
+        questionSelectDrainMatcher,
         slowAbortMatcher,
         slowBusyMatcher,
         typingRepulseMatcher,
@@ -760,6 +829,7 @@ export function createDeterministicMatchers() {
         actionButtonClickFollowupMatcher,
         questionToolMatcher,
         questionSelectQueueMatcher,
+        questionAfterTextMatcher,
         permissionTypingMatcher,
         permissionTypingFollowupMatcher,
         externalDirectoryProbeMatcher,
@@ -787,7 +857,7 @@ export const TEST_USER_ID = '200000000000000991';
  * Each caller should use a unique channelId and dirName to avoid collisions
  * when vitest runs files in parallel.
  */
-export function setupQueueAdvancedSuite({ channelId, channelName, dirName, username, restrictExternalDirectories = false, projectPermission, }) {
+export function setupQueueAdvancedSuite({ channelId, channelName, dirName, username, restrictExternalDirectories = false, projectPermission, extraMatchers = [], }) {
     const ctx = {
         directories: undefined,
         discord: undefined,
@@ -828,7 +898,10 @@ export function setupQueueAdvancedSuite({ channelId, channelName, dirName, usern
             providerNpm,
             model: 'deterministic-v2',
             smallModel: 'deterministic-v3',
-            settings: { strict: false, matchers: createDeterministicMatchers() },
+            settings: {
+                strict: false,
+                matchers: [...createDeterministicMatchers(), ...extraMatchers],
+            },
         });
         fs.writeFileSync(path.join(ctx.directories.projectDirectory, 'opencode.json'), JSON.stringify(projectPermission
             ? { ...opencodeConfig, permission: projectPermission }