kimaki 0.28.0 → 0.30.0

package/dist/message-formatting.test.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { afterEach, describe, test, expect } from 'vitest';
-import { asDiscordQuote, batchChunksForDiscord, collectSessionChunks, formatBashToolTitle, formatPart, formatTaskToolTitle, formatTodoList, getTextAttachments, planAssistantTurnFlush, serializeEmbeds, serializePoll, serializeMessageSnapshots, sessionPartContent, shouldLeadWithBlankLine, TEXT_ATTACHMENT_INLINE_LIMIT_BYTES } from './message-formatting.js';
+import { asDiscordQuote, asSystemLine, batchChunksForDiscord, collectSessionChunks, formatBashToolTitle, formatPart, formatTaskToolTitle, formatTodoList, getTextAttachments, planAssistantTurnFlush, quotedTextFitsOneDiscordMessage, serializeEmbeds, serializePoll, serializeMessageSnapshots, sessionPartContent, shouldLeadWithBlankLine, TEXT_ATTACHMENT_INLINE_LIMIT_BYTES } from './message-formatting.js';
 import { getDataDir } from './config.js';
 describe('formatPart', () => {
     test('callout text is returned without a diamond prefix', () => {
@@ -42,6 +42,39 @@ describe('formatPart', () => {
       Done."
     `);
     });
+    test('synthetic user context stays hidden', () => {
+        const part = {
+            id: 'prt_branch',
+            type: 'text',
+            sessionID: 'ses_test',
+            messageID: 'msg_user',
+            text: '\n[current git branch is main]\n',
+            synthetic: true,
+        };
+        expect(formatPart(part)).toBe('');
+    });
+    test('ignored plugin notices stay visible', () => {
+        const part = {
+            id: 'prt_notice',
+            type: 'text',
+            sessionID: 'ses_test',
+            messageID: 'msg_notice',
+            text: 'Subrouter: Using openai/gpt-5.6-sol because xai/grok-4.6 is rate limited.',
+            ignored: true,
+        };
+        expect(formatPart(part)).toBe('Subrouter: Using openai/gpt-5.6-sol because xai/grok-4.6 is rate limited.');
+    });
+});
+describe('asSystemLine', () => {
+    test('prefixes every line', () => {
+        expect(asSystemLine('hello\nworld')).toMatchInlineSnapshot(`
+      "-# hello
+      -# world"
+    `);
+    });
+    test('does not double-prefix', () => {
+        expect(asSystemLine('-# already marked')).toMatchInlineSnapshot(`"-# already marked"`);
+    });
 });
 describe('asDiscordQuote', () => {
     test('prefixes every line', () => {
@@ -61,6 +94,14 @@ describe('asDiscordQuote', () => {
     `);
     });
 });
+describe('quotedTextFitsOneDiscordMessage', () => {
+    test('accepts a short line', () => {
+        expect(quotedTextFitsOneDiscordMessage('done')).toBe(true);
+    });
+    test('rejects text whose quote would split across Discord messages', () => {
+        expect(quotedTextFitsOneDiscordMessage('x'.repeat(1999))).toBe(false);
+    });
+});
 describe('planAssistantTurnFlush', () => {
     function text(id, body, ended = true) {
         return { id, type: 'text', text: body, time: ended ? { end: 1 } : undefined };
@@ -144,7 +185,7 @@ describe('planAssistantTurnFlush', () => {
       }
     `);
     });
-    test('progress holds unfinished last text and following tools', () => {
+    test('progress sends tools immediately while unfinished text is held', () => {
         expect(plan([text('t1', 'status', false), tool('tool1')], 'progress')).toMatchInlineSnapshot(`
       {
         "hold": [
@@ -152,15 +193,51 @@ describe('planAssistantTurnFlush', () => {
             "id": "t1",
             "quoteText": false,
           },
+        ],
+        "send": [
           {
             "id": "tool1",
             "quoteText": false,
           },
         ],
+      }
+    `);
+    });
+    test('progress holds unfinished text only when nothing else is ready', () => {
+        expect(plan([text('t1', 'status', false)], 'progress')).toMatchInlineSnapshot(`
+      {
+        "hold": [
+          {
+            "id": "t1",
+            "quoteText": false,
+          },
+        ],
         "send": [],
       }
     `);
     });
+    test('progress sends completed text and later tools while later text is still open', () => {
+        expect(plan([text('t1', 'first'), text('t2', 'second', false), tool('tool1')], 'progress')).toMatchInlineSnapshot(`
+      {
+        "hold": [
+          {
+            "id": "t2",
+            "quoteText": false,
+          },
+        ],
+        "send": [
+          {
+            "id": "t1",
+            "quoteText": true,
+          },
+          {
+            "id": "tool1",
+            "quoteText": false,
+          },
+        ],
+      }
+    `);
+    });
     test('progress holds unfinished last text until it ends', () => {
         expect(plan([text('t1', 'first'), text('t2', 'second', false)], 'progress')).toMatchInlineSnapshot(`
       {
@@ -284,6 +361,17 @@ describe('planAssistantTurnFlush', () => {
     test('progress still quotes two-line earlier text', () => {
         expect(plan([text('t1', 'line one\nline two'), tool('tool1'), text('t2', 'answer')], 'progress').send.find((entry) => entry.id === 't1')).toEqual({ id: 't1', quoteText: true });
     });
+    test('progress keeps sleep-tool quote context after that tool is already sent', () => {
+        const parts = [text('t1', 'wait'), tool('sleep1', 'kimaki_sleep')];
+        expect(plan(parts, 'progress').send.find((entry) => entry.id === 't1')).toEqual({
+            id: 't1',
+            quoteText: false,
+        });
+        expect(plan([text('t1', 'wait')], 'progress').send.find((entry) => entry.id === 't1')).toEqual({
+            id: 't1',
+            quoteText: true,
+        });
+    });
     test('progress does not quote earlier text before an interactive tool', () => {
         expect(plan([text('t1', 'ask'), tool('question1', 'question'), text('t2', 'later')], 'progress').send.find((entry) => entry.id === 't1')).toEqual({ id: 't1', quoteText: false });
         expect(plan([text('t1', 'wait'), tool('sleep1', 'kimaki_sleep'), text('t2', 'later')], 'progress').send.find((entry) => entry.id === 't1')).toEqual({ id: 't1', quoteText: false });
@@ -318,15 +406,35 @@ describe('sessionPartContent', () => {
     });
 });
 describe('collectSessionChunks', () => {
-    function textPart({ id, text, messageID, }) {
+    function textPart({ id, text, messageID, synthetic, }) {
         return {
             id,
             type: 'text',
             sessionID: 'ses_test',
             messageID,
             text,
+            synthetic,
         };
     }
+    test('skips synthetic text parts', () => {
+        const { chunks } = collectSessionChunks({
+            messages: [
+                {
+                    info: { role: 'assistant', id: 'msg_1', parentID: 'msg_user' },
+                    parts: [
+                        textPart({
+                            id: 'branch',
+                            text: '\n[current git branch is main]\n',
+                            messageID: 'msg_1',
+                            synthetic: true,
+                        }),
+                        textPart({ id: 't1', text: 'working', messageID: 'msg_1' }),
+                    ],
+                },
+            ],
+        });
+        expect(chunks.map((chunk) => chunk.content)).toEqual(['> working']);
+    });
     test('quotes short text throughout a turn', () => {
         const { chunks } = collectSessionChunks({
             messages: [

package/dist/opencode.js

@@ -305,16 +305,21 @@ function ensureProcessCleanupHandlersRegistered() {
         killSingleServerProcessNow({ reason: 'process-exit' });
         killStartingServerProcessNow({ reason: 'process-exit' });
     });
-    // Fallback for short-lived CLI subcommands that call process.exit without
-    // running discord-bot.ts shutdown handlers.
-    process.on('SIGINT', () => {
-        killSingleServerProcessNow({ reason: 'sigint' });
-        killStartingServerProcessNow({ reason: 'sigint' });
-    });
-    process.on('SIGTERM', () => {
-        killSingleServerProcessNow({ reason: 'sigterm' });
-        killStartingServerProcessNow({ reason: 'sigterm' });
-    });
+    // Fallback for CLI subcommands without their own signal handling. Any signal
+    // listener disables Node's default exit, so if we are the only listener we
+    // must exit ourselves. Otherwise the process ignores Ctrl+C and, in the bot,
+    // keeps holding the hrana lock port. If another owner exists (the bot
+    // lifecycle handlers, a subcommand), it decides when to exit.
+    for (const signal of ['SIGINT', 'SIGTERM']) {
+        process.on(signal, () => {
+            killSingleServerProcessNow({ reason: signal.toLowerCase() });
+            killStartingServerProcessNow({ reason: signal.toLowerCase() });
+            if (process.listenerCount(signal) > 1) {
+                return;
+            }
+            process.exit(128 + os.constants.signals[signal]);
+        });
+    }
 }
 // ── Resolve opencode binary ──────────────────────────────────────
 // Resolve the full path to the opencode binary so we can spawn without
@@ -806,6 +811,15 @@ async function startSingleServer({ directory, } = {}) {
         return waitResult;
     }
     serverReady = true;
+    // stopOpencodeServer() may have run while we waited (bot shutdown). Never
+    // publish a server that nobody will stop.
+    if (global.shuttingDown || serverProcess.killed) {
+        killStartingServerProcessNow({ reason: 'stopped-during-startup' });
+        if (startingServerProcess === serverProcess) {
+            startingServerProcess = null;
+        }
+        return new ServerStartError({ port, reason: 'stopped during startup' });
+    }
     opencodeLogger.log(`Server ready on port ${port}`);
     // Always dump startup logs so plugin loading errors and other startup output
     // are visible in kimaki.log.
@@ -1143,6 +1157,9 @@ export function extractSdkErrorMessage(error) {
  * Used for process teardown, tests, and explicit restarts.
  */
 export async function stopOpencodeServer() {
+    // A server still booting lives only in startingServerProcess.
+    killStartingServerProcessNow({ reason: 'stop-opencode-server' });
+    startingServerProcess = null;
     if (!singleServer) {
         return false;
     }
@@ -1168,8 +1185,6 @@ export async function stopOpencodeServer() {
             opencodeLogger.warn(killResult.message);
         }
     }
-    killStartingServerProcessNow({ reason: 'stop-opencode-server' });
-    startingServerProcess = null;
     singleServer = null;
     clientCache.clear();
     serverRetryCount = 0;

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

@@ -78,7 +78,7 @@ describe('abort clears pending question dropdown', () => {
         "--- from: user (question-abort-tester)
         QUESTION_SELECT_QUEUE_MARKER abort-test
         --- from: assistant (TestBot)
-        > *using deterministic-provider/deterministic-v2*
+        -# *using deterministic-provider/deterministic-v2*
         **Select action**
         How to proceed?
         [user selects dropdown: 0]

package/dist/question-abort-resume.e2e.test.js

@@ -0,0 +1,100 @@
+// E2e test: a question answered after its run was aborted elsewhere must not be
+// lost. The original run is dead, so question.reply is a no-op; kimaki resumes
+// the session by sending the answers back as a fresh prompt.
+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 { getOpencodeClient } from './opencode.js';
+import { getThreadSession } from './database.js';
+import { getRuntime } from './session-handler/thread-session-runtime.js';
+const TEXT_CHANNEL_ID = '200000000000001032';
+describe('question answered after external abort resumes session', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-question-abort-resume',
+        dirName: 'qa-question-abort-resume',
+        username: 'question-resume-tester',
+    });
+    test('answering a dropdown after opencode abort resumes with the answers', async () => {
+        const marker = 'QUESTION_ABORT_RESUME_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);
+        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];
+        // Abort directly through opencode (simulating a different opencode client),
+        // so kimaki's dropdown context stays live but the question is gone in
+        // opencode. kimaki's own abort would clear the dropdown instead.
+        const sessionId = await getThreadSession(thread.id);
+        if (!sessionId) {
+            throw new Error('Expected session id');
+        }
+        const client = getOpencodeClient(ctx.directories.projectDirectory);
+        if (!client) {
+            throw new Error('Expected opencode client');
+        }
+        await client.session.abort({
+            sessionID: sessionId,
+            directory: ctx.directories.projectDirectory,
+        });
+        // Wait until kimaki sees the session go idle (mirrors a user answering
+        // after they aborted in another opencode).
+        const runtime = getRuntime(thread.id);
+        if (!runtime) {
+            throw new Error('Expected runtime');
+        }
+        const idleStart = Date.now();
+        while (runtime.isBusy() && Date.now() - idleStart < 8_000) {
+            await new Promise((resolve) => {
+                setTimeout(resolve, 50);
+            });
+        }
+        expect(runtime.isBusy()).toBe(false);
+        // Answer the dropdown. reply fails (question no longer pending), so kimaki
+        // resumes the session with the answers as a new prompt.
+        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,
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: 'resumed-after-abort',
+            timeout: 12_000,
+        });
+        const timeline = await th.text({ showInteractions: true });
+        expect(timeline).toContain('How to proceed?');
+        expect(timeline).toContain('» **question-resume-tester:** Alpha');
+        expect(timeline).toContain('resumed-after-abort');
+    }, 25_000);
+});

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

@@ -127,7 +127,7 @@ describe('question text before dropdown after abort retry', () => {
         "--- from: user (question-abort-retry-tester)
         ABORT_RETRY_LEFTOVER_TEXT_MARKER
         --- from: assistant (TestBot)
-        > *using deterministic-provider/deterministic-v2*
+        -# *using deterministic-provider/deterministic-v2*
         > abort-retry-started
         --- from: user (question-abort-retry-tester)
         QUESTION_AFTER_ABORT_RETRY_MARKER

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

@@ -34,7 +34,7 @@ describe('question text before dropdown', () => {
         "--- from: user (question-text-tester)
         QUESTION_AFTER_TEXT_MARKER
         --- from: assistant (TestBot)
-        > *using deterministic-provider/deterministic-v2*
+        -# *using deterministic-provider/deterministic-v2*
         PLAN_TEXT_BEFORE_QUESTION
         **Next step**
         What next?"

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

@@ -153,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*
+        -# *using deterministic-provider/deterministic-v2*
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (queue-advanced-tester)
         SLOW_ABORT_MARKER run long response"
       `);
@@ -284,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*
+        -# *using deterministic-provider/deterministic-v2*
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         **Action Required**
         _Selected: Continue action-buttons flow_
         [user clicks button]
         » **queue-action-tester:** Continue action-buttons flow
         > action-buttons-click-continued
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         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*
+        -# *using deterministic-provider/deterministic-v2*
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         **Action Required**
         _Buttons dismissed._
         --- from: user (queue-action-tester)

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

@@ -820,8 +820,71 @@ export function createDeterministicMatchers() {
             ],
         },
     };
+    // Question tool for the abort-then-answer case: model asks a question via
+    // dropdown. The test aborts the run before answering (session goes idle),
+    // then answers via select. Because the original run is dead, kimaki resumes
+    // the session by sending the answers back as a new prompt.
+    const questionAbortResumeMatcher = {
+        id: 'question-abort-resume-marker',
+        priority: 107,
+        when: {
+            lastMessageRole: 'user',
+            latestUserTextIncludes: 'QUESTION_ABORT_RESUME_MARKER',
+            rawPromptRegex: '^(?!.*question-abort-resume-call)',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                {
+                    type: 'tool-call',
+                    toolCallId: 'question-abort-resume-call',
+                    toolName: 'question',
+                    input: JSON.stringify({
+                        questions: [{
+                                question: 'How to proceed?',
+                                header: 'Select action',
+                                options: [
+                                    { label: 'Alpha', description: 'Alpha option' },
+                                    { label: 'Beta', description: 'Beta option' },
+                                ],
+                            }],
+                    }),
+                },
+                {
+                    type: 'finish',
+                    finishReason: 'tool-calls',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+        },
+    };
+    // Follow-up after an aborted question is answered: kimaki resumes with a
+    // prompt containing the answers summary.
+    const questionAbortResumeFollowupMatcher = {
+        id: 'question-abort-resume-followup',
+        priority: 107,
+        when: {
+            lastMessageRole: 'user',
+            latestUserTextIncludes: 'Answers to your previous questions:',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'resume-reply' },
+                { type: 'text-delta', id: 'resume-reply', delta: 'resumed-after-abort' },
+                { type: 'text-end', id: 'resume-reply' },
+                {
+                    type: 'finish',
+                    finishReason: 'stop',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+        },
+    };
     return [
         questionSelectDrainMatcher,
+        questionAbortResumeMatcher,
+        questionAbortResumeFollowupMatcher,
         slowAbortMatcher,
         slowBusyMatcher,
         typingRepulseMatcher,

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

@@ -34,9 +34,9 @@ e2eTest('queue advanced: footer emission', () => {
         "--- from: user (queue-advanced-tester)
         Reply with exactly: footer-check
         --- from: assistant (TestBot)
-        > *using deterministic-provider/deterministic-v2*
+        -# *using deterministic-provider/deterministic-v2*
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         const foundFooter = footerMessages.some((m) => {
             return m.author.id === ctx.discord.botUserId
@@ -44,16 +44,16 @@ e2eTest('queue advanced: footer emission', () => {
         });
         expect(foundFooter).toBe(true);
     }, 8_000);
-    test('skip-footer-mentions omits the thread creator mention', async () => {
-        store.setState({ footerMentionsEnabled: false });
+    test('enable-footer-mentions mentions the thread creator', async () => {
+        store.setState({ footerMentionsEnabled: true });
         try {
             await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
-                content: 'Reply with exactly: footer-without-mention',
+                content: 'Reply with exactly: footer-with-mention',
             });
             const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
                 timeout: 4_000,
                 predicate: (t) => {
-                    return t.name === 'Reply with exactly: footer-without-mention';
+                    return t.name === 'Reply with exactly: footer-with-mention';
                 },
             });
             const th = ctx.discord.thread(thread.id);
@@ -65,15 +65,15 @@ e2eTest('queue advanced: footer emission', () => {
             });
             expect(await th.text()).toMatchInlineSnapshot(`
           "--- from: user (queue-advanced-tester)
-          Reply with exactly: footer-without-mention
+          Reply with exactly: footer-with-mention
           --- from: assistant (TestBot)
-          > *using deterministic-provider/deterministic-v2*
+          -# *using deterministic-provider/deterministic-v2*
           > ok
-          > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2*"
+          -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>"
         `);
         }
         finally {
-            store.setState({ footerMentionsEnabled: true });
+            store.setState({ footerMentionsEnabled: false });
         }
     }, 8_000);
     test('footer appears after second message in same session', async () => {
@@ -121,14 +121,14 @@ e2eTest('queue advanced: footer emission', () => {
         "--- from: user (queue-advanced-tester)
         Reply with exactly: footer-multi-setup
         --- from: assistant (TestBot)
-        > *using deterministic-provider/deterministic-v2*
+        -# *using deterministic-provider/deterministic-v2*
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (queue-advanced-tester)
         Reply with exactly: footer-multi-second
         --- from: assistant (TestBot)
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         if (footerCount >= 2) {
             expect(footerCount).toBeGreaterThanOrEqual(2);
@@ -216,9 +216,9 @@ e2eTest('queue advanced: footer emission', () => {
         "--- from: user (queue-advanced-tester)
         Reply with exactly: interrupt-footer-setup
         --- from: assistant (TestBot)
-        > *using deterministic-provider/deterministic-v2*
+        -# *using deterministic-provider/deterministic-v2*
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (queue-advanced-tester)
         PLUGIN_TIMEOUT_SLEEP_MARKER
         --- from: assistant (TestBot)
@@ -227,7 +227,7 @@ e2eTest('queue advanced: footer emission', () => {
         Reply with exactly: interrupt-footer-followup
         --- from: assistant (TestBot)
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         expect(followupUserIdx).toBeGreaterThanOrEqual(0);
         expect(okReplyIdx).toBeGreaterThan(followupUserIdx);
@@ -274,13 +274,13 @@ e2eTest('queue advanced: footer emission', () => {
         "--- from: user (queue-advanced-tester)
         TOOL_CALL_FOOTER_MARKER
         --- from: assistant (TestBot)
-        > *using deterministic-provider/deterministic-v2*
+        -# *using deterministic-provider/deterministic-v2*
         > running tool
 
         ┣ bash _echo tool-call-footer-test_
 
         > tool call completed
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
     }, 10_000);
 });

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

@@ -248,9 +248,9 @@ describe('queue advanced: /model with interrupt recovery', () => {
         "--- from: user (queue-model-switch-tester)
         Reply with exactly: model-switcher-setup
         --- from: assistant (TestBot)
-        > *using deterministic-provider/deterministic-v2*
+        -# *using deterministic-provider/deterministic-v2*
         > ok
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         Model set for this session:
         **Deterministic Provider** / **deterministic-v3**
         \`deterministic-provider/deterministic-v3\`
@@ -259,13 +259,12 @@ describe('queue advanced: /model with interrupt recovery', () => {
         --- 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 ⋅ <1s ⋅ 0% ⋅ deterministic-v3* <@200000000000000991>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v3*"
       `);
         expect(footer).toBeDefined();
         expect(footer?.content).toContain('deterministic-v3');

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

@@ -89,7 +89,7 @@ describe('queue advanced: typing around permissions', () => {
         "--- from: user (queue-permission-tester)
         PERMISSION_TYPING_MARKER
         --- from: assistant (TestBot)
-        > *using deterministic-provider/deterministic-v2*
+        -# *using deterministic-provider/deterministic-v2*
         > requesting external read permission
 
         ┣ read *.zprofile*
@@ -101,7 +101,7 @@ describe('queue advanced: typing around permissions', () => {
         [user clicks button]
 
         > permission-flow-done
-        > *project ⋅ main ⋅ 2s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         const timeline = await th.text({
             showTyping: true,