kimaki 0.26.0 → 0.28.0

package/dist/thread-message-queue.e2e.test.js

@@ -21,7 +21,7 @@ import { startDiscordBot } from './discord-bot.js';
 import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChannelVerbosity, getChannelVerbosity, } from './database.js';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { initializeOpencodeForDirectory, stopOpencodeServer } from './opencode.js';
-import { chooseLockPort, cleanupTestSessions, initTestGitRepo, waitForFooterMessage, waitForBotMessageContaining, waitForMessageById, waitForBotMessageCount, waitForBotReplyAfterUserMessage, waitForThreadState, } from './test-utils.js';
+import { chooseLockPort, cleanupTestSessions, initTestGitRepo, waitForFooterMessage, waitForBotMessageContaining, waitForMessageById, waitForBotMessageCount, waitForBotReplyAfterUserMessage, waitForThreadState, getMessageVisibleText, } from './test-utils.js';
 const e2eTest = describe;
 function createRunDirectories() {
     const root = path.resolve(process.cwd(), 'tmp', 'thread-queue-e2e');
@@ -70,6 +70,13 @@ function createDeterministicMatchers() {
                     delta: 'running create file',
                 },
                 { type: 'text-end', id: 'bash-create-file' },
+                { type: 'text-start', id: 'bash-create-file-status' },
+                {
+                    type: 'text-delta',
+                    id: 'bash-create-file-status',
+                    delta: 'creating marker',
+                },
+                { type: 'text-end', id: 'bash-create-file-status' },
                 {
                     type: 'tool-call',
                     toolCallId: 'bash-create-file-call',
@@ -361,7 +368,7 @@ e2eTest('thread message queue ordering', () => {
             discord,
             threadId: thread.id,
             userId: TEST_USER_ID,
-            text: '⬥ ok',
+            text: 'ok',
             timeout: 10_000,
         });
         await waitForFooterMessage({
@@ -373,9 +380,9 @@ e2eTest('thread message queue ordering', () => {
         "--- from: user (queue-tester)
         Reply with exactly: cold-start-stream
         --- 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* <@200000000000000777>"
       `);
     }, 12_000);
     test('text message during active session gets processed', async () => {
@@ -394,7 +401,7 @@ e2eTest('thread message queue ordering', () => {
         const firstReply = await th.waitForBotReply({
             timeout: 4_000,
         });
-        expect(firstReply.content.trim().length).toBeGreaterThan(0);
+        expect(getMessageVisibleText(firstReply).trim().length).toBeGreaterThan(0);
         // Snapshot bot message count before sending follow-up
         const before = await th.getMessages();
         const beforeBotCount = before.filter((m) => {
@@ -428,7 +435,7 @@ e2eTest('thread message queue ordering', () => {
         const timeline = await th.text();
         expect(timeline).toContain('Reply with exactly: alpha');
         expect(timeline).toContain('Reply with exactly: beta');
-        expect(timeline).toContain('⬥ ok');
+        expect(timeline).toContain('ok');
         expect(timeline).toContain('*project ⋅ main ⋅');
         // User B's message must appear before the new bot response
         const userBIndex = after.findIndex((m) => {
@@ -443,7 +450,7 @@ e2eTest('thread message queue ordering', () => {
         expect(userBIndex).toBeLessThan(lastBotIndex);
         // New bot response has non-empty content
         const newBotReply = afterBotMessages[afterBotMessages.length - 1];
-        expect(newBotReply.content.trim().length).toBeGreaterThan(0);
+        expect(getMessageVisibleText(newBotReply).trim().length).toBeGreaterThan(0);
     }, 12_000);
     test('two rapid text messages in thread — both processed in order', async () => {
         // 1. Send initial message to text channel → thread + session established
@@ -463,7 +470,7 @@ e2eTest('thread message queue ordering', () => {
         const firstReply = await th.waitForBotReply({
             timeout: 4_000,
         });
-        expect(firstReply.content.trim().length).toBeGreaterThan(0);
+        expect(getMessageVisibleText(firstReply).trim().length).toBeGreaterThan(0);
         await waitForFooterMessage({
             discord,
             threadId: thread.id,
@@ -497,18 +504,18 @@ e2eTest('thread message queue ordering', () => {
             return m.author.id === discord.botUserId;
         });
         expect(afterBotMessages.length).toBeGreaterThanOrEqual(beforeBotCount + 1);
-        expect(await th.text()).toMatchInlineSnapshot(`
+        expect((await th.text()).replace(/\nok(?=\nok)/g, '')).toMatchInlineSnapshot(`
         "--- from: user (queue-tester)
         Reply with exactly: one
         --- 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* <@200000000000000777>
         --- from: user (queue-tester)
         Reply with exactly: two
         Reply with exactly: three
         --- from: assistant (TestBot)
-        ⬥ ok"
+        > ok"
       `);
         const userThreeIndex = after.findIndex((message) => {
             return (message.author.id === TEST_USER_ID &&
@@ -521,7 +528,7 @@ e2eTest('thread message queue ordering', () => {
         expect(botAfterThreeIndex).toBeGreaterThan(userThreeIndex);
         const newBotReplies = afterBotMessages.slice(beforeBotCount);
         expect(newBotReplies.some((reply) => {
-            return reply.content.trim().length > 0;
+            return getMessageVisibleText(reply).trim().length > 0;
         })).toBe(true);
         const finalState = await waitForThreadState({
             threadId: thread.id,
@@ -533,88 +540,6 @@ e2eTest('thread message queue ordering', () => {
         });
         expect(finalState.queueItems.length).toBe(0);
     }, 8_000);
-    test('normal messages bypass local queue and still show assistant text parts', async () => {
-        const setupPrompt = 'Reply with exactly: opencode-queue-setup';
-        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
-            content: setupPrompt,
-        });
-        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
-            timeout: 4_000,
-            predicate: (t) => {
-                return t.name === 'Reply with exactly: opencode-queue-setup';
-            },
-        });
-        const th = discord.thread(thread.id);
-        const firstReply = await th.waitForBotReply({ timeout: 4_000 });
-        expect(firstReply.content.trim().length).toBeGreaterThan(0);
-        // Anchor follow-up on an already-completed first run so footer ordering
-        // is deterministic before we assert on the second prompt.
-        await waitForFooterMessage({
-            discord,
-            threadId: thread.id,
-            timeout: 4_000,
-        });
-        const followupPrompt = 'Prompt from test: respond with short text for opencode queue mode.';
-        const followupUserMessage = await th.user(TEST_USER_ID).sendMessage({
-            content: followupPrompt,
-        });
-        // Assert assistant text parts are visible in Discord.
-        await waitForBotMessageContaining({
-            discord,
-            threadId: thread.id,
-            userId: TEST_USER_ID,
-            text: '⬥ ok',
-            afterMessageId: followupUserMessage.id,
-            timeout: 4_000,
-        });
-        const messagesWithFollowupFooter = await waitForFooterMessage({
-            discord,
-            threadId: thread.id,
-            timeout: 4_000,
-            afterMessageIncludes: followupPrompt,
-            afterAuthorId: TEST_USER_ID,
-        });
-        expect(await th.text()).toMatchInlineSnapshot(`
-        "--- from: user (queue-tester)
-        Reply with exactly: opencode-queue-setup
-        --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        --- from: user (queue-tester)
-        Prompt from test: respond with short text for opencode queue mode.
-        --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `);
-        const followupUserIndex = messagesWithFollowupFooter.findIndex((message) => {
-            return message.id === followupUserMessage.id;
-        });
-        const textPartAfterFollowupIndex = messagesWithFollowupFooter.findIndex((message, index) => {
-            return (index > followupUserIndex &&
-                message.author.id === discord.botUserId &&
-                message.content.includes('⬥ ok'));
-        });
-        const footerAfterFollowupIndex = messagesWithFollowupFooter.findIndex((message, index) => {
-            return (index > textPartAfterFollowupIndex &&
-                message.author.id === discord.botUserId &&
-                message.content.startsWith('*') &&
-                message.content.includes('⋅'));
-        });
-        expect(followupUserIndex).toBeGreaterThan(-1);
-        expect(textPartAfterFollowupIndex).toBeGreaterThan(followupUserIndex);
-        expect(footerAfterFollowupIndex).toBeGreaterThan(textPartAfterFollowupIndex);
-        // Normal messages should not populate kimaki local queue.
-        const noLocalQueueState = await waitForThreadState({
-            threadId: thread.id,
-            predicate: (state) => {
-                return state.queueItems.length === 0;
-            },
-            timeout: 4_000,
-            description: 'local queue remains empty in opencode mode',
-        });
-        expect(noLocalQueueState.queueItems.length).toBe(0);
-    }, 8_000);
     test('bash tool-call actually executes and creates file in project directory', async () => {
         const markerRelativePath = path.join('tmp', 'bash-tool-executed.txt');
         const markerPath = path.join(directories.projectDirectory, markerRelativePath);
@@ -654,11 +579,14 @@ e2eTest('thread message queue ordering', () => {
         "--- from: user (queue-tester)
         Reply with exactly: BASH_TOOL_FILE_MARKER
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ running create file
-        ┣ bash _mkdir -p tmp && printf "created" > tmp/bash-tool-executed.txt_
-        ⬥ file created
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > *using deterministic-provider/deterministic-v2*
+        > running create file
+        > creating marker
+
+        ┣ bash _Create marker file for e2e test_
+
+        > file created
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000777>"
       `);
         expect(fs.existsSync(markerPath)).toBe(true);
         const markerContents = fs.readFileSync(markerPath, 'utf8');
@@ -676,7 +604,7 @@ e2eTest('thread message queue ordering', () => {
         });
         const th = discord.thread(thread.id);
         const firstReply = await th.waitForBotReply({ timeout: 4_000 });
-        expect(firstReply.content.trim().length).toBeGreaterThan(0);
+        expect(getMessageVisibleText(firstReply).trim().length).toBeGreaterThan(0);
         // Ensure the setup run is fully settled before slash-queue checks.
         // Otherwise the first /queue call can race with a still-busy run window.
         await waitForFooterMessage({
@@ -746,7 +674,7 @@ e2eTest('thread message queue ordering', () => {
         await waitForBotMessageContaining({
             discord,
             threadId: thread.id,
-            text: '⬥ ok',
+            text: 'ok',
             afterMessageId: dispatchIndicatorMessage.id,
             timeout: 8_000,
         });
@@ -754,23 +682,23 @@ e2eTest('thread message queue ordering', () => {
             discord,
             threadId: thread.id,
             timeout: 8_000,
-            afterMessageIncludes: '⬥ ok',
+            afterMessageIncludes: 'ok',
             afterAuthorId: discord.botUserId,
         });
         expect(await th.text()).toMatchInlineSnapshot(`
         "--- from: user (queue-tester)
         Reply with exactly: queue-slash-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* <@200000000000000777>
         » **queue-tester:** Reply with exactly: race-final
         Queued message (position 1)
-        ⬥ race-final
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > race-final
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2*
         » **queue-tester:** Reply with exactly: queued-from-slash
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000777>"
       `);
     }, 12_000);
     test('Remove from queue button clears only that queued message', async () => {
@@ -864,7 +792,7 @@ e2eTest('thread message queue ordering', () => {
             discord,
             threadId: thread.id,
             timeout: 8_000,
-            afterMessageIncludes: '⬥ ok',
+            afterMessageIncludes: 'ok',
             afterAuthorId: discord.botUserId,
         });
         const threadText = await th.text();
@@ -872,96 +800,19 @@ e2eTest('thread message queue ordering', () => {
         "--- from: user (queue-tester)
         Reply with exactly: clear-queue-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* <@200000000000000777>
         » **queue-tester:** Reply with exactly: race-final
         Removed queued message (was position 1): Reply with exactly: removed-queued-message
         Queued message (position 2)
-        ⬥ race-final
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > race-final
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2*
         » **queue-tester:** Reply with exactly: kept-queued-message"
       `);
         expect(threadText).not.toContain('» **queue-tester:** Reply with exactly: removed-queued-message');
         expect(threadText).toContain('kept-queued-message');
     }, 12_000);
-    test('queued message waits for running session and then processes next', async () => {
-        // When a new message arrives while a session is running, it queues and
-        // runs after the in-flight request completes.
-        //
-        // 1. Fast setup: establish session
-        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
-            content: 'Reply with exactly: delta',
-        });
-        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
-            timeout: 4_000,
-            predicate: (t) => {
-                return t.name === 'Reply with exactly: delta';
-            },
-        });
-        const th = discord.thread(thread.id);
-        const firstReply = await th.waitForBotReply({ timeout: 4_000 });
-        expect(firstReply.content.trim().length).toBeGreaterThan(0);
-        const before = await th.getMessages();
-        const beforeBotCount = before.filter((m) => {
-            return m.author.id === discord.botUserId;
-        }).length;
-        // 2. Send B, then quickly send C to enqueue behind B.
-        await th.user(TEST_USER_ID).sendMessage({
-            content: 'Reply with exactly: echo',
-        });
-        await new Promise((r) => {
-            setTimeout(r, 500);
-        });
-        await th.user(TEST_USER_ID).sendMessage({
-            content: 'Reply with exactly: foxtrot',
-        });
-        // 3. Poll until foxtrot's user message has a bot reply after it.
-        //    waitForBotMessageCount alone isn't enough — error messages from the
-        //    interrupted session can satisfy the count before foxtrot gets its reply.
-        const after = await waitForBotReplyAfterUserMessage({
-            discord,
-            threadId: thread.id,
-            userId: TEST_USER_ID,
-            userMessageIncludes: 'foxtrot',
-            timeout: 4_000,
-        });
-        // 4. Foxtrot got a bot response after B/C were processed.
-        const afterBotMessages = after.filter((m) => {
-            return m.author.id === discord.botUserId;
-        });
-        expect(afterBotMessages.length).toBeGreaterThanOrEqual(beforeBotCount + 1);
-        await waitForFooterMessage({
-            discord,
-            threadId: thread.id,
-            timeout: 4_000,
-            afterMessageIncludes: 'foxtrot',
-            afterAuthorId: TEST_USER_ID,
-        });
-        // Assert ordering invariants instead of exact snapshot — the echo reply
-        // and footer can interleave non-deterministically on slower CI hardware.
-        const finalMessages = await th.getMessages();
-        const userEchoIndex = finalMessages.findIndex((m) => {
-            return m.author.id === TEST_USER_ID && m.content.includes('echo');
-        });
-        const userFoxtrotIndex = finalMessages.findIndex((m) => {
-            return m.author.id === TEST_USER_ID && m.content.includes('foxtrot');
-        });
-        expect(userEchoIndex).toBeGreaterThan(-1);
-        expect(userFoxtrotIndex).toBeGreaterThan(-1);
-        // User messages appear in send order
-        expect(userEchoIndex).toBeLessThan(userFoxtrotIndex);
-        // Foxtrot's bot reply appears after the foxtrot user message
-        const botAfterFoxtrot = finalMessages.findIndex((m, i) => {
-            return i > userFoxtrotIndex && m.author.id === discord.botUserId;
-        });
-        expect(botAfterFoxtrot).toBeGreaterThan(userFoxtrotIndex);
-        // A footer appears after foxtrot (session completed)
-        const timeline = await th.text();
-        expect(timeline).toContain('Reply with exactly: echo');
-        expect(timeline).toContain('Reply with exactly: foxtrot');
-        expect(timeline).toContain('*project ⋅ main ⋅');
-    }, 8_000);
     test('slow stream still processes queued next message after completion', async () => {
         // A message sent mid-stream queues and runs after the in-flight request
         // completes (no auto-interrupt).
@@ -977,7 +828,7 @@ e2eTest('thread message queue ordering', () => {
         });
         const th = discord.thread(thread.id);
         const firstReply = await th.waitForBotReply({ timeout: 4_000 });
-        expect(firstReply.content.trim().length).toBeGreaterThan(0);
+        expect(getMessageVisibleText(firstReply).trim().length).toBeGreaterThan(0);
         // Wait for golf's footer so the golf→hotel transition is deterministic
         await waitForFooterMessage({
             discord,
@@ -1017,14 +868,14 @@ e2eTest('thread message queue ordering', () => {
         "--- from: user (queue-tester)
         Reply with exactly: golf
         --- 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* <@200000000000000777>
         --- from: user (queue-tester)
         Reply with exactly: hotel
         Reply with exactly: india
         --- from: assistant (TestBot)
-        ⬥ ok"
+        > ok"
       `);
         const userIndiaIndex = after.findIndex((m) => {
             return m.author.id === TEST_USER_ID && m.content.includes('india');
@@ -1049,7 +900,7 @@ e2eTest('thread message queue ordering', () => {
         });
         const th = discord.thread(thread.id);
         const firstReply = await th.waitForBotReply({ timeout: 4_000 });
-        expect(firstReply.content.trim().length).toBeGreaterThan(0);
+        expect(getMessageVisibleText(firstReply).trim().length).toBeGreaterThan(0);
         const before = await th.getMessages();
         const beforeBotCount = before.filter((m) => {
             return m.author.id === discord.botUserId;
@@ -1087,12 +938,12 @@ e2eTest('thread message queue ordering', () => {
         const textWithoutFooters = (await th.text())
             .split('\n')
             .filter((line) => {
-            return !line.startsWith('*project ⋅');
+            return !line.startsWith('*project ⋅') && !line.startsWith('> *project ⋅');
         })
             .join('\n');
         const normalizedTextWithoutFooters = textWithoutFooters.replace([
             '--- from: assistant (TestBot)',
-            '⬥ ok',
+            'ok',
             '--- from: user (queue-tester)',
             'Reply with exactly: november',
         ].join('\n'), [
@@ -1104,16 +955,17 @@ e2eTest('thread message queue ordering', () => {
         "--- from: user (queue-tester)
         Reply with exactly: juliet
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
         --- from: user (queue-tester)
         Reply with exactly: kilo
         Reply with exactly: lima
         Reply with exactly: mike
         --- from: assistant (TestBot)
+        > ok
         --- from: user (queue-tester)
         Reply with exactly: november
         --- from: assistant (TestBot)
-        ⬥ ok"
+        > ok"
       `);
         // E's user message appears before the final bot response
         const userNovemberIndex = afterE.findIndex((m) => {
@@ -1198,17 +1050,17 @@ e2eTest('thread message queue ordering', () => {
         "--- from: user (queue-tester)
         SLOW_BUSY_MARKER Reply with exactly: edit-queue-setup
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
         --- from: user (queue-tester)
         Reply with exactly: edited-queued. queue
         --- from: assistant (TestBot)
         Queued at position 1. Edit or delete your message to update the queue
         ⬦ **queue-tester** edited queued message
-        ⬥ slow-busy-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > slow-busy-reply
+        > *project ⋅ main ⋅ 2s ⋅ 0% ⋅ deterministic-v2*
         » **queue-tester:** Reply with exactly: edited-queued
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000777>"
       `);
         const finalText = await th.text();
         expect(finalText).toContain('edited-queued');
@@ -1291,14 +1143,14 @@ e2eTest('thread message queue ordering', () => {
         "--- from: user (queue-tester)
         SLOW_BUSY_MARKER Reply with exactly: remove-queue-setup
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
         --- from: user (queue-tester)
         Reply with exactly: will-be-removed
         --- from: assistant (TestBot)
         Queued at position 1. Edit or delete your message to update the queue
         ⬦ **queue-tester** removed message from queue
-        ⬥ slow-busy-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > slow-busy-reply
+        > *project ⋅ main ⋅ 2s ⋅ 0% ⋅ deterministic-v2* <@200000000000000777>"
       `);
     }, 12_000);
 });

package/dist/undo-redo.e2e.test.js

@@ -19,7 +19,7 @@ import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-set
 import { waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
 import { getThreadSession } from './database.js';
 import { initializeOpencodeForDirectory } from './opencode.js';
-const TEXT_CHANNEL_ID = '200000000000001200';
+const TEXT_CHANNEL_ID = '200000000000003205';
 const e2eTest = describe;
 e2eTest('/undo sets revert state and cleans up on next prompt', () => {
     const ctx = setupQueueAdvancedSuite({
@@ -46,7 +46,13 @@ e2eTest('/undo sets revert state and cleans up on next prompt', () => {
             },
         });
         const th = ctx.discord.thread(thread.id);
-        await th.waitForBotReply({ timeout: 4_000 });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'creating undo file',
+            timeout: 8_000,
+        });
         await waitForFooterMessage({
             discord: ctx.discord,
             threadId: thread.id,
@@ -147,17 +153,19 @@ e2eTest('/undo sets revert state and cleans up on next prompt', () => {
         "--- from: user (undo-tester)
         UNDO_FILE_MARKER
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ creating undo file
-        ┣ bash _mkdir -p tmp && printf created > tmp/undo-marker.txt_
-        ⬥ undo file created
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
+        > creating undo file
+
+        ┣ bash _Create undo marker file_
+
+        > undo file created
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>
         Undone - reverted last assistant message
         --- from: user (undo-tester)
         Reply with exactly: after-undo-message
         --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
       `);
     }, 20_000);
 });

package/dist/voice-attachment.js

@@ -2,17 +2,39 @@
 // Normalizes Discord attachment heuristics for voice-message detection so
 // message routing, transcription, and empty-prompt guards all agree even when
 // Discord omits contentType on uploaded audio attachments.
+// iOS videos also have duration_secs; reject those before the duration heuristic.
 import path from 'node:path';
 const VOICE_ATTACHMENT_EXTENSIONS = new Set([
     '.m4a',
     '.mp3',
-    '.mp4',
     '.oga',
     '.ogg',
     '.opus',
     '.wav',
 ]);
+const VIDEO_ATTACHMENT_EXTENSIONS = new Set([
+    '.avi',
+    '.m4v',
+    '.mkv',
+    '.mov',
+    '.mp4',
+    '.webm',
+]);
+function isVisualMediaAttachment(attachment) {
+    const contentType = attachment.contentType?.trim().toLowerCase() || '';
+    if (contentType.startsWith('video/'))
+        return true;
+    const extension = path.extname(attachment.name || '').toLowerCase();
+    if (VIDEO_ATTACHMENT_EXTENSIONS.has(extension))
+        return true;
+    return (typeof attachment.width === 'number' &&
+        attachment.width > 0 &&
+        typeof attachment.height === 'number' &&
+        attachment.height > 0);
+}
 export function getVoiceAttachmentMatchReason(attachment) {
+    if (isVisualMediaAttachment(attachment))
+        return null;
     const contentType = attachment.contentType?.trim().toLowerCase() || '';
     if (contentType.startsWith('audio/')) {
         return `contentType:${contentType}`;

package/dist/voice-handler.js

@@ -16,7 +16,7 @@ import { transcribeViaKimakiGateway } from './cloudflare-transcription.js';
 import { sendThreadMessage, escapeDiscordFormatting, NOTIFY_MESSAGE_FLAGS, hasKimakiBotPermission, } from './discord-utils.js';
 import { requestAudioApiKey } from './commands/gemini-apikey.js';
 import { transcribeAudio } from './voice.js';
-import { DiscordOperationError, FetchError } from './errors.js';
+import { DiscordOperationError, FetchError, EmptyTranscriptionError, TranscriptionError } from './errors.js';
 import { store } from './store.js';
 import { getVoiceAttachmentMatchReason, isVoiceAttachment, } from './voice-attachment.js';
 import { execAsync } from './worktrees.js';
@@ -352,7 +352,7 @@ export async function cleanupVoiceConnection(guildId) {
 }
 // Per-thread serialization is handled by ThreadSessionRuntime.enqueueIncoming()
 // via the runtime action queue; no local serialization is needed here.
-export async function processVoiceAttachment({ message, thread, projectDirectory, isNewThread = false, appId, currentSessionContext, lastSessionContext, agents, }) {
+export async function processVoiceAttachment({ message, thread, projectDirectory, isNewThread = false, appId, currentSessionContext, lastSessionContext, agents, canForkSession = false, }) {
     const audioAttachment = Array.from(message.attachments.values()).find((attachment) => isVoiceAttachment(attachment));
     if (!audioAttachment)
         return null;
@@ -387,7 +387,12 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
             transcription: deterministicConfig.transcription,
             queueMessage: deterministicConfig.queueMessage,
             agent: deterministicConfig.agent,
+            sessionAction: deterministicConfig.sessionAction,
         };
+        if (!result.transcription.trim()) {
+            await sendThreadMessage(thread, 'No request was transcribed. Record another voice message with the task to send.');
+            return new EmptyTranscriptionError();
+        }
         voiceLogger.log(`[DETERMINISTIC] Returning canned transcription: "${result.transcription}"${result.queueMessage ? ' [QUEUE]' : ''}`);
         if (isNewThread) {
             const threadName = result.transcription.replace(/\s+/g, ' ').trim().slice(0, 80);
@@ -402,6 +407,10 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
             }
         }
         await sendThreadMessage(thread, `📝 **Transcribed message:** ${escapeDiscordFormatting(result.transcription)}`);
+        if (result.sessionAction === 'btw' && !canForkSession) {
+            await sendThreadMessage(thread, 'A contextual side chat needs an existing session. Nothing was sent to the agent. Retry from a session, or ask to create a fresh chat with this request.');
+            return new TranscriptionError({ reason: 'Contextual routing is unavailable without a source session' });
+        }
         return result;
     }
     const audioResponse = await fetch(audioAttachment.url)
@@ -450,7 +459,7 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
     // No user-configured key: gateway-mode installs get one free transcription
     // via the kimaki.dev Whisper fallback before we bother the user with the
     // "add API key" dialog. This fallback has no tool-calling, so it can't
-    // detect queueMessage/agent hints spoken in the voice message the way the
+    // detect queueMessage/sessionAction/agent hints spoken in the voice message the way the
     // OpenAI/Gemini path can.
     let gatewayTranscription;
     if (!transcriptionApiKey) {
@@ -496,13 +505,17 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
             currentSessionContext,
             lastSessionContext,
             agents,
+            canForkSession,
         });
     if (transcription instanceof Error) {
+        if (transcription instanceof EmptyTranscriptionError) {
+            await sendThreadMessage(thread, 'No request was transcribed. Record another voice message with the task to send.');
+            return transcription;
+        }
         const errMsg = errore.matchError(transcription, {
             ApiKeyMissingError: (e) => e.message,
             InvalidAudioFormatError: (e) => e.message,
             TranscriptionError: (e) => e.message,
-            EmptyTranscriptionError: (e) => e.message,
             NoResponseContentError: (e) => e.message,
             NoToolResponseError: (e) => e.message,
             Error: (e) => e.message,
@@ -539,6 +552,10 @@ export async function processVoiceAttachment({ message, thread, projectDirectory
         }
     }
     await sendThreadMessage(thread, `📝 **Transcribed message:** ${escapeDiscordFormatting(text)}`);
+    if (transcription.sessionAction === 'btw' && !canForkSession) {
+        await sendThreadMessage(thread, 'A contextual side chat needs an existing session. Nothing was sent to the agent. Retry from a session, or ask to create a fresh chat with this request.');
+        return new TranscriptionError({ reason: 'Contextual routing is unavailable without a source session' });
+    }
     if (agent) {
         await sendThreadMessage(thread, `Detected agent: ${agent}`);
     }