kimaki 0.4.85 → 0.4.87

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

@@ -302,7 +302,8 @@ describe('agent model resolution', () => {
         Reply with exactly: agent-model-check
         --- from: assistant (TestBot)
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
+        ⬥ ok"
       `);
         expect(footerMessage).toBeDefined();
         if (!footerMessage) {
@@ -345,7 +346,7 @@ describe('agent model resolution', () => {
         Reply with exactly: system-context-check
         --- from: assistant (TestBot)
         ⬥ system-context-ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
+        *project ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***"
       `);
     }, 15_000);
     test('new thread uses channel model when channel model preference is set', async () => {

package/dist/commands/ask-question.js

@@ -11,6 +11,11 @@ const logger = createLogger(LogPrefix.ASK_QUESTION);
 // TTL prevents unbounded growth if user never answers a question.
 const QUESTION_CONTEXT_TTL_MS = 10 * 60 * 1000;
 export const pendingQuestionContexts = new Map();
+export function hasPendingQuestionForThread(threadId) {
+    return [...pendingQuestionContexts.values()].some((ctx) => {
+        return ctx.thread.id === threadId;
+    });
+}
 /**
  * Show dropdown menus for question tool input.
  * Sends one message per question with the dropdown directly under the question text.
@@ -205,13 +210,21 @@ export function parseAskUserQuestionTool(part) {
     return input;
 }
 /**
- * Cancel a pending question for a thread (e.g., when user sends a new message).
- * Sends the user's message as the answer to OpenCode so the model sees their actual response.
+ * Cancel a pending question for a thread.
+ *
+ * Two modes depending on whether `userMessage` is provided:
+ *
+ * - `cancelPendingQuestion(threadId)` — cleanup only. Removes the context
+ *   without replying to OpenCode. Use when aborting the blocked session
+ *   separately (e.g. voice/attachment messages whose content needs
+ *   transcription first). Returns 'no-pending' in both "found+cleaned" and
+ *   "nothing found" cases.
  *
- * Returns 'replied' if the question was answered successfully (caller should NOT
- * enqueue the user message as a new prompt — it was consumed as the answer).
- * Returns 'reply-failed' if reply failed (context kept pending so TTL can retry).
- * Returns 'no-pending' if no question was pending for this thread.
+ * - `cancelPendingQuestion(threadId, text)` — reply path. Sends the text as
+ *   the tool answer so the model sees the user's response. The caller should
+ *   NOT also enqueue the message as a new prompt.
+ *   Returns 'replied' on success, 'reply-failed' if the reply call fails
+ *   (context kept pending so TTL can retry).
  */
 export async function cancelPendingQuestion(threadId, userMessage) {
     // Find pending question for this thread
@@ -228,8 +241,9 @@ export async function cancelPendingQuestion(threadId, userMessage) {
         return 'no-pending';
     }
     // undefined means teardown/cleanup — just remove context, don't reply.
-    // The session is already being torn down. Empty string '' is a valid
-    // user message (attachment-only, voice, etc.) and must still go through.
+    // The session is already being torn down or the caller wants to dismiss
+    // the question without providing an answer (e.g. voice/attachment-only
+    // messages where content needs transcription before it can be an answer).
     if (userMessage === undefined) {
         pendingQuestionContexts.delete(contextHash);
         return 'no-pending';

package/dist/commands/btw.js

@@ -0,0 +1,111 @@
+// /btw command - Fork the current session with full context and send a new prompt.
+// Unlike /fork, this does not replay past messages in Discord. It just creates
+// a new thread, forks the entire session (no messageID), and immediately
+// dispatches the user's prompt so the forked session starts working right away.
+import { ChannelType, ThreadAutoArchiveDuration, MessageFlags, } from 'discord.js';
+import { getThreadSession, setThreadSession } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveWorkingDirectory, resolveTextChannel, sendThreadMessage, } from '../discord-utils.js';
+import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
+import { createLogger, LogPrefix } from '../logger.js';
+const logger = createLogger(LogPrefix.FORK);
+export async function handleBtwCommand({ command, appId, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await command.reply({
+            content: 'This command can only be used in a thread with an active session',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const prompt = command.options.getString('prompt', true);
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const { projectDirectory } = resolved;
+    const sessionId = await getThreadSession(channel.id);
+    if (!sessionId) {
+        await command.reply({
+            content: 'No active session in this thread',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    await command.deferReply({ flags: MessageFlags.Ephemeral });
+    const getClient = await initializeOpencodeForDirectory(projectDirectory);
+    if (getClient instanceof Error) {
+        await command.editReply({
+            content: `Failed to fork session: ${getClient.message}`,
+        });
+        return;
+    }
+    try {
+        // Fork the entire session (no messageID = fork at the latest point)
+        const forkResponse = await getClient().session.fork({
+            sessionID: sessionId,
+        });
+        if (!forkResponse.data) {
+            await command.editReply('Failed to fork session');
+            return;
+        }
+        const forkedSession = forkResponse.data;
+        const textChannel = await resolveTextChannel(channel);
+        if (!textChannel) {
+            await command.editReply('Could not resolve parent text channel');
+            return;
+        }
+        const threadName = `btw: ${prompt}`.slice(0, 100);
+        const thread = await textChannel.threads.create({
+            name: threadName,
+            autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+            reason: `btw fork from session ${sessionId}`,
+        });
+        // Claim the forked session immediately so external polling does not race
+        await setThreadSession(thread.id, forkedSession.id);
+        await thread.members.add(command.user.id);
+        logger.log(`Created btw fork session ${forkedSession.id} in thread ${thread.id} from ${sessionId}`);
+        // Short status message with prompt instead of replaying past messages
+        const sourceThreadLink = `<#${channel.id}>`;
+        await sendThreadMessage(thread, `Reusing context from ${sourceThreadLink} to answer prompt...\n${prompt}`);
+        // Create runtime and dispatch the prompt immediately
+        const runtime = getOrCreateRuntime({
+            threadId: thread.id,
+            thread,
+            projectDirectory,
+            sdkDirectory: projectDirectory,
+            channelId: textChannel.id,
+            appId,
+        });
+        await runtime.enqueueIncoming({
+            prompt,
+            userId: command.user.id,
+            username: command.user.displayName,
+            appId,
+            mode: 'opencode',
+        });
+        await command.editReply(`Session forked! Continue in ${thread.toString()}`);
+    }
+    catch (error) {
+        logger.error('Error in /btw:', error);
+        await command.editReply(`Failed to fork session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/discord-bot.js

@@ -12,7 +12,7 @@ import { getTextAttachments, resolveMentions, } from './message-formatting.js';
 import { isVoiceAttachment } from './voice-attachment.js';
 import { preprocessExistingThreadMessage, preprocessNewThreadMessage, } from './message-preprocessing.js';
 import { cancelPendingActionButtons } from './commands/action-buttons.js';
-import { cancelPendingQuestion } from './commands/ask-question.js';
+import { cancelPendingQuestion, hasPendingQuestionForThread } from './commands/ask-question.js';
 import { cancelPendingFileUpload } from './commands/file-upload.js';
 import { cancelPendingPermission } from './commands/permissions.js';
 import { cancelHtmlActionsForThread } from './html-actions.js';
@@ -438,9 +438,6 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     appId: currentAppId,
                 });
                 // Cancel interactive UI when a real user sends a message.
-                // If a question was pending and answered with the user's text,
-                // early-return: the message was consumed as the question answer
-                // and must NOT also be sent as a new prompt (causes abort loops).
                 if (!message.author.bot && !isCliInjectedPrompt) {
                     cancelPendingActionButtons(thread.id);
                     cancelHtmlActionsForThread(thread.id);
@@ -450,11 +447,30 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                             reason: 'user sent a new message while permission was pending',
                         });
                     }
-                    const questionResult = await cancelPendingQuestion(thread.id, message.content);
-                    void cancelPendingFileUpload(thread.id);
-                    if (questionResult === 'replied') {
-                        return;
+                    // For text messages: pass the content as the question answer so the
+                    // model sees the user's response. The early return prevents the message
+                    // from also being sent as a new prompt (duplicate).
+                    // For voice/image messages: message.content is "" (audio is in
+                    // attachments, transcription happens later). Passing "" as the answer
+                    // loses the content entirely. Instead, reply with "" to properly
+                    // unblock OpenCode's question.waitForReply (without a reply the next
+                    // promptAsync immediately fails with MessageAbortedError), then let
+                    // the voice message flow through normal preprocessing — it gets
+                    // transcribed and queued as the next user message after the model
+                    // finishes responding to the empty answer.
+                    if (message.content.trim().length > 0) {
+                        const questionResult = await cancelPendingQuestion(thread.id, message.content);
+                        if (questionResult === 'replied') {
+                            void cancelPendingFileUpload(thread.id);
+                            return;
+                        }
                     }
+                    else if (hasPendingQuestionForThread(thread.id)) {
+                        // Reply empty to unblock the question tool — no early return so
+                        // the voice/image message continues through to enqueueIncoming.
+                        await cancelPendingQuestion(thread.id, '');
+                    }
+                    void cancelPendingFileUpload(thread.id);
                 }
                 // Expensive pre-processing (voice transcription, context fetch,
                 // attachment download) runs inside the runtime's serialized

package/dist/discord-command-registration.js

@@ -161,11 +161,6 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
         })
             .setDMPermission(false)
             .toJSON(),
-        new SlashCommandBuilder()
-            .setName('toggle-mention-mode')
-            .setDescription(truncateCommandDescription('Toggle mention-only mode (bot only responds when @mentioned)'))
-            .setDMPermission(false)
-            .toJSON(),
         new SlashCommandBuilder()
             .setName('add-project')
             .setDescription(truncateCommandDescription('Create Discord channels for a project. Use `npx kimaki project add` for unlisted projects'))
@@ -214,11 +209,6 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .setDescription(truncateCommandDescription('Compact the session context by summarizing conversation history'))
             .setDMPermission(false)
             .toJSON(),
-        new SlashCommandBuilder()
-            .setName('stop')
-            .setDescription(truncateCommandDescription('Abort the current OpenCode request in this thread'))
-            .setDMPermission(false)
-            .toJSON(),
         new SlashCommandBuilder()
             .setName('share')
             .setDescription(truncateCommandDescription('Share the current session as a public URL'))
@@ -234,6 +224,18 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .setDescription(truncateCommandDescription('Fork the session from a past user message'))
             .setDMPermission(false)
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('btw')
+            .setDescription(truncateCommandDescription('Ask something without polluting or blocking the current session'))
+            .addStringOption((option) => {
+            option
+                .setName('prompt')
+                .setDescription(truncateCommandDescription('The message to send in the forked session'))
+                .setRequired(true);
+            return option;
+        })
+            .setDMPermission(false)
+            .toJSON(),
         new SlashCommandBuilder()
             .setName('model')
             .setDescription(truncateCommandDescription('Set the preferred model for this channel or session'))
@@ -338,11 +340,6 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .setDescription(truncateCommandDescription('Show current session ID and opencode attach command for this thread'))
             .setDMPermission(false)
             .toJSON(),
-        new SlashCommandBuilder()
-            .setName('memory-snapshot')
-            .setDescription(truncateCommandDescription('Write a V8 heap snapshot to disk for memory debugging'))
-            .setDMPermission(false)
-            .toJSON(),
         new SlashCommandBuilder()
             .setName('upgrade-and-restart')
             .setDescription(truncateCommandDescription('Upgrade kimaki to the latest version and restart the bot'))
@@ -369,10 +366,43 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .setDMPermission(false)
             .toJSON(),
     ];
-    // Add user-defined commands with source-based suffixes (-cmd / -skill)
+    // Dynamic commands are registered in priority order: agents → user commands → skills → MCP prompts.
+    // This ordering matters because we slice to MAX_DISCORD_COMMANDS (100) at the end,
+    // so lower-priority dynamic commands get trimmed first if the total exceeds the limit.
+    // 1. Agent-specific quick commands like /plan-agent, /build-agent
+    // Filter to primary/all mode agents (same as /agent command shows), excluding hidden agents
+    const primaryAgents = agents.filter((a) => (a.mode === 'primary' || a.mode === 'all') && !a.hidden);
+    for (const agent of primaryAgents) {
+        const sanitizedName = sanitizeAgentName(agent.name);
+        // Skip if sanitized name is empty or would create invalid command name
+        // Discord command names must start with a lowercase letter or number
+        if (!sanitizedName || !/^[a-z0-9]/.test(sanitizedName)) {
+            continue;
+        }
+        // Truncate base name before appending suffix so the -agent suffix is never
+        // lost to Discord's 32-char command name limit.
+        const agentSuffix = '-agent';
+        const agentBaseName = sanitizedName.slice(0, 32 - agentSuffix.length);
+        const commandName = `${agentBaseName}${agentSuffix}`;
+        const description = buildQuickAgentCommandDescription({
+            agentName: agent.name,
+            description: agent.description,
+        });
+        commands.push(new SlashCommandBuilder()
+            .setName(commandName)
+            .setDescription(truncateCommandDescription(description))
+            .setDMPermission(false)
+            .toJSON());
+    }
+    // 2. User-defined commands, skills, and MCP prompts (ordered by priority)
     // Also populate registeredUserCommands in the store for /queue-command autocomplete
     const newRegisteredCommands = [];
-    for (const cmd of userCommands) {
+    // Sort: regular commands first, then skills, then MCP prompts
+    const sourceOrder = { config: 0, skill: 1, mcp: 2 };
+    const sortedUserCommands = [...userCommands].sort((a, b) => {
+        return (sourceOrder[a.source || ''] ?? 0) - (sourceOrder[b.source || ''] ?? 0);
+    });
+    for (const cmd of sortedUserCommands) {
         if (SKIP_USER_COMMANDS.includes(cmd.name)) {
             continue;
         }
@@ -415,30 +445,12 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .toJSON());
     }
     store.setState({ registeredUserCommands: newRegisteredCommands });
-    // Add agent-specific quick commands like /plan-agent, /build-agent
-    // Filter to primary/all mode agents (same as /agent command shows), excluding hidden agents
-    const primaryAgents = agents.filter((a) => (a.mode === 'primary' || a.mode === 'all') && !a.hidden);
-    for (const agent of primaryAgents) {
-        const sanitizedName = sanitizeAgentName(agent.name);
-        // Skip if sanitized name is empty or would create invalid command name
-        // Discord command names must start with a lowercase letter or number
-        if (!sanitizedName || !/^[a-z0-9]/.test(sanitizedName)) {
-            continue;
-        }
-        // Truncate base name before appending suffix so the -agent suffix is never
-        // lost to Discord's 32-char command name limit.
-        const agentSuffix = '-agent';
-        const agentBaseName = sanitizedName.slice(0, 32 - agentSuffix.length);
-        const commandName = `${agentBaseName}${agentSuffix}`;
-        const description = buildQuickAgentCommandDescription({
-            agentName: agent.name,
-            description: agent.description,
-        });
-        commands.push(new SlashCommandBuilder()
-            .setName(commandName)
-            .setDescription(truncateCommandDescription(description))
-            .setDMPermission(false)
-            .toJSON());
+    // Discord allows max 100 guild commands. Slice to stay within the limit,
+    // trimming lowest-priority dynamic commands (MCP prompts, then skills) first.
+    const MAX_DISCORD_COMMANDS = 100;
+    if (commands.length > MAX_DISCORD_COMMANDS) {
+        cliLogger.warn(`COMMANDS: ${commands.length} commands exceed Discord limit of ${MAX_DISCORD_COMMANDS}, truncating to ${MAX_DISCORD_COMMANDS}`);
+        commands.length = MAX_DISCORD_COMMANDS;
     }
     const rest = createDiscordRest(token);
     const uniqueGuildIds = Array.from(new Set(guildIds.filter((guildId) => guildId)));

package/dist/interaction-handler.js

@@ -8,7 +8,6 @@ import { handleMergeWorktreeCommand, handleMergeWorktreeAutocomplete, } from './
 import { handleToggleWorktreesCommand } from './commands/worktree-settings.js';
 import { handleWorktreesCommand } from './commands/worktrees.js';
 import { handleTasksCommand } from './commands/tasks.js';
-import { handleToggleMentionModeCommand } from './commands/mention-mode.js';
 import { handleResumeCommand, handleResumeAutocomplete, } from './commands/resume.js';
 import { handleAddProjectCommand, handleAddProjectAutocomplete, } from './commands/add-project.js';
 import { handleRemoveProjectCommand, handleRemoveProjectAutocomplete, } from './commands/remove-project.js';
@@ -19,6 +18,7 @@ import { handleCompactCommand } from './commands/compact.js';
 import { handleShareCommand } from './commands/share.js';
 import { handleDiffCommand } from './commands/diff.js';
 import { handleForkCommand, handleForkSelectMenu } from './commands/fork.js';
+import { handleBtwCommand } from './commands/btw.js';
 import { handleModelCommand, handleProviderSelectMenu, handleModelSelectMenu, handleModelScopeSelectMenu, } from './commands/model.js';
 import { handleUnsetModelCommand } from './commands/unset-model.js';
 import { handleLoginCommand, handleLoginSelect, handleLoginTextButton, handleLoginTextModalSubmit, handleLoginApiKeyButton, handleOAuthCodeButton, handleOAuthCodeModalSubmit, handleApiKeyModalSubmit, } from './commands/login.js';
@@ -36,7 +36,6 @@ import { handleRestartOpencodeServerCommand } from './commands/restart-opencode-
 import { handleRunCommand } from './commands/run-command.js';
 import { handleContextUsageCommand } from './commands/context-usage.js';
 import { handleSessionIdCommand } from './commands/session-id.js';
-import { handleMemorySnapshotCommand } from './commands/memory-snapshot.js';
 import { handleUpgradeAndRestartCommand } from './commands/upgrade.js';
 import { handleMcpCommand, handleMcpSelectMenu } from './commands/mcp.js';
 import { handleScreenshareCommand, handleScreenshareStopCommand, } from './commands/screenshare.js';
@@ -120,12 +119,6 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                             appId,
                         });
                         return;
-                    case 'toggle-mention-mode':
-                        await handleToggleMentionModeCommand({
-                            command: interaction,
-                            appId,
-                        });
-                        return;
                     case 'resume':
                         await handleResumeCommand({ command: interaction, appId });
                         return;
@@ -142,7 +135,6 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                         });
                         return;
                     case 'abort':
-                    case 'stop':
                         await handleAbortCommand({ command: interaction, appId });
                         return;
                     case 'compact':
@@ -157,6 +149,9 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     case 'fork':
                         await handleForkCommand(interaction);
                         return;
+                    case 'btw':
+                        await handleBtwCommand({ command: interaction, appId });
+                        return;
                     case 'model':
                         await handleModelCommand({ interaction, appId });
                         return;
@@ -205,12 +200,6 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                     case 'session-id':
                         await handleSessionIdCommand({ command: interaction, appId });
                         return;
-                    case 'memory-snapshot':
-                        await handleMemorySnapshotCommand({
-                            command: interaction,
-                            appId,
-                        });
-                        return;
                     case 'upgrade-and-restart':
                         await handleUpgradeAndRestartCommand({
                             command: interaction,

package/dist/markdown.test.js

@@ -184,6 +184,22 @@ test('generate markdown with system info', async () => {
 
 
     *Completed in Xs*
+
+    ### 🤖 Assistant (deterministic-v2)
+
+    **Started using deterministic-provider/deterministic-v2**
+
+    Hello! This is a deterministic markdown test response.
+
+
+    *Completed in Xs*
+
+    ### 🤖 Assistant (deterministic-v2)
+
+    **Started using deterministic-provider/deterministic-v2**
+
+    Hello! This is a deterministic markdown test response.
+
     "
   `);
 });
@@ -219,6 +235,22 @@ test('generate markdown without system info', async () => {
 
 
     *Completed in Xs*
+
+    ### 🤖 Assistant (deterministic-v2)
+
+    **Started using deterministic-provider/deterministic-v2**
+
+    Hello! This is a deterministic markdown test response.
+
+
+    *Completed in Xs*
+
+    ### 🤖 Assistant (deterministic-v2)
+
+    **Started using deterministic-provider/deterministic-v2**
+
+    Hello! This is a deterministic markdown test response.
+
     "
   `);
 });

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

@@ -95,6 +95,7 @@ e2eTest('queue advanced: footer emission', () => {
         Reply with exactly: footer-multi-second
         --- from: assistant (TestBot)
         ⬥ ok
+        ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         if (footerCount >= 2) {
@@ -190,11 +191,14 @@ e2eTest('queue advanced: footer emission', () => {
         --- from: user (queue-advanced-tester)
         PLUGIN_TIMEOUT_SLEEP_MARKER
         --- from: assistant (TestBot)
+        ⬥ ok
         ⬥ starting sleep 100
         --- from: user (queue-advanced-tester)
         Reply with exactly: interrupt-footer-followup
         --- from: assistant (TestBot)
         ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         expect(followupUserIdx).toBeGreaterThanOrEqual(0);
@@ -267,15 +271,19 @@ e2eTest('queue advanced: footer emission', () => {
         --- from: assistant (TestBot)
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ ok
         --- from: user (queue-advanced-tester)
         PLUGIN_TIMEOUT_SLEEP_MARKER
         --- from: assistant (TestBot)
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ ok
         ⬥ starting sleep 100
         --- from: user (queue-advanced-tester)
         Reply with exactly: plugin-timeout-after
         --- from: assistant (TestBot)
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ ok"
       `);
         expect(afterIndex).toBeGreaterThanOrEqual(0);
         const okReplyIndex = messagesWithFooter.findIndex((message, index) => {
@@ -355,8 +363,10 @@ e2eTest('queue advanced: footer emission', () => {
         TOOL_CALL_FOOTER_MARKER
         --- from: assistant (TestBot)
         ⬥ running tool
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ ok"
       `);
         // Only ONE footer at the end — the tool-call step's footer is NOT
         // emitted mid-turn. The final text follow-up gets the footer.
@@ -406,6 +416,19 @@ e2eTest('queue advanced: footer emission', () => {
         MULTI_TOOL_FOOTER_MARKER
         --- from: assistant (TestBot)
         ⬥ investigating the issue
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ all done, fixed 3 files
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ all done, fixed 3 files
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ all done, fixed 3 files
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ all done, fixed 3 files
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ all done, fixed 3 files
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ all done, fixed 3 files
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         ⬥ all done, fixed 3 files
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
@@ -459,10 +482,24 @@ e2eTest('queue advanced: footer emission', () => {
         MULTI_STEP_CHAIN_MARKER
         --- from: assistant (TestBot)
         ⬥ chain step 1: reading config
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         ⬥ chain step 2: analyzing results
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         ⬥ chain step 3: applying fix
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         ⬥ chain complete: all 3 steps done
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ chain complete: all 3 steps done
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ chain complete: all 3 steps done
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ chain complete: all 3 steps done
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ chain complete: all 3 steps done
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ chain complete: all 3 steps done
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ chain complete: all 3 steps done"
       `);
         // The critical assertion: only 1 footer at the very end.
         // With the naive "allow tool-calls as natural completion" fix,

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

@@ -252,14 +252,20 @@ describe('queue advanced: /model with interrupt recovery', () => {
         --- from: assistant (TestBot)
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ ok
         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_
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ ok
         --- from: user (queue-model-switch-tester)
         PLUGIN_TIMEOUT_SLEEP_MARKER
         --- from: assistant (TestBot)
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         ⬥ ok
         ⬥ starting sleep 100
         --- from: user (queue-model-switch-tester)

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

@@ -171,6 +171,7 @@ describe('queue advanced: typing around permissions', () => {
         --- from: user (queue-permission-tester)
         Reply with exactly: post-permission-user-message
         --- from: assistant (TestBot)
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);