kimaki 0.12.0 → 0.13.0

package/dist/btw-prefix-detection.js

@@ -1,17 +1,15 @@
-// Detects the raw `btw ` Discord message shortcut used to fork a side-question
-// thread without invoking the /btw slash command UI.
-export function extractBtwPrefix(content) {
-    if (!content) {
-        return null;
+// Detects `. btw` suffix at the end of a Discord message, identical pattern
+// to the queue suffix. When present the suffix is stripped and the remaining
+// message is forked to a new btw thread via /btw.
+//
+// Supported forms:
+// - punctuation + btw: ". btw", "! btw", ". btw.", "!btw."
+// - btw as its own final line: "text\nbtw"
+// Non-matches: "btw fix this" (start only), "hello btw" (no punctuation)
+const BTW_SUFFIX_RE = /(?:[.!?,;:])\s*btw\.?\s*$|\n\s*btw\.?\s*$/i;
+export function extractBtwSuffix(content) {
+    if (!BTW_SUFFIX_RE.test(content)) {
+        return { prompt: content, forceBtw: false };
     }
-    // Match "btw" followed by whitespace or punctuation (. , : ; ! ?) then the prompt
-    const match = content.match(/^\s*btw[.,;:!?\s]\s*([\s\S]+)$/i);
-    if (!match) {
-        return null;
-    }
-    const prompt = match[1]?.trim();
-    if (!prompt) {
-        return null;
-    }
-    return { prompt };
+    return { prompt: content.replace(BTW_SUFFIX_RE, '').trimEnd(), forceBtw: true };
 }

package/dist/btw-prefix-detection.test.js

@@ -1,63 +1,93 @@
 import { describe, expect, test } from 'vitest';
-import { extractBtwPrefix } from './btw-prefix-detection.js';
-describe('extractBtwPrefix', () => {
-    test('matches lowercase prefix', () => {
-        expect(extractBtwPrefix('btw fix this')).toMatchInlineSnapshot(`
+import { extractBtwSuffix } from './btw-prefix-detection.js';
+describe('extractBtwSuffix', () => {
+    test('matches after period', () => {
+        expect(extractBtwSuffix('fix the bug. btw')).toMatchInlineSnapshot(`
       {
-        "prompt": "fix this",
+        "forceBtw": true,
+        "prompt": "fix the bug",
       }
     `);
     });
-    test('matches uppercase prefix', () => {
-        expect(extractBtwPrefix('BTW check this')).toMatchInlineSnapshot(`
+    test('matches after exclamation', () => {
+        expect(extractBtwSuffix('done! btw')).toMatchInlineSnapshot(`
       {
-        "prompt": "check this",
+        "forceBtw": true,
+        "prompt": "done",
       }
     `);
     });
-    test('keeps multiline content', () => {
-        expect(extractBtwPrefix('  btw first line\nsecond line  ')).toMatchInlineSnapshot(`
+    test('matches after comma', () => {
+        expect(extractBtwSuffix('sure, btw')).toMatchInlineSnapshot(`
       {
-        "prompt": "first line
-      second line",
+        "forceBtw": true,
+        "prompt": "sure",
       }
     `);
     });
-    test('matches dot separator', () => {
-        expect(extractBtwPrefix('btw. fix this')).toMatchInlineSnapshot(`
+    test('matches after newline', () => {
+        expect(extractBtwSuffix('fix the bug\nbtw')).toMatchInlineSnapshot(`
       {
-        "prompt": "fix this",
+        "forceBtw": true,
+        "prompt": "fix the bug",
       }
     `);
     });
-    test('matches comma separator', () => {
-        expect(extractBtwPrefix('btw, fix this')).toMatchInlineSnapshot(`
+    test('matches with trailing dot', () => {
+        expect(extractBtwSuffix('fix the bug. btw.')).toMatchInlineSnapshot(`
       {
-        "prompt": "fix this",
+        "forceBtw": true,
+        "prompt": "fix the bug",
       }
     `);
     });
-    test('matches colon separator', () => {
-        expect(extractBtwPrefix('btw: fix this')).toMatchInlineSnapshot(`
+    test('case insensitive', () => {
+        expect(extractBtwSuffix('done. BTW')).toMatchInlineSnapshot(`
       {
-        "prompt": "fix this",
+        "forceBtw": true,
+        "prompt": "done",
       }
     `);
     });
-    test('matches punctuation without trailing space', () => {
-        expect(extractBtwPrefix('btw.fix this')).toMatchInlineSnapshot(`
+    test('no space between punctuation and btw', () => {
+        expect(extractBtwSuffix('done.btw')).toMatchInlineSnapshot(`
       {
-        "prompt": "fix this",
+        "forceBtw": true,
+        "prompt": "done",
       }
     `);
     });
-    test('does not match without separating whitespace', () => {
-        expect(extractBtwPrefix('btwfix this')).toMatchInlineSnapshot(`null`);
+    test('does not match at start of message', () => {
+        expect(extractBtwSuffix('btw fix this')).toMatchInlineSnapshot(`
+      {
+        "forceBtw": false,
+        "prompt": "btw fix this",
+      }
+    `);
     });
-    test('does not match mid-message', () => {
-        expect(extractBtwPrefix('hello btw fix this')).toMatchInlineSnapshot(`null`);
+    test('does not match mid-message without punctuation', () => {
+        expect(extractBtwSuffix('hello btw')).toMatchInlineSnapshot(`
+      {
+        "forceBtw": false,
+        "prompt": "hello btw",
+      }
+    `);
     });
-    test('does not match empty payload', () => {
-        expect(extractBtwPrefix('btw   ')).toMatchInlineSnapshot(`null`);
+    test('does not match empty content', () => {
+        expect(extractBtwSuffix('')).toMatchInlineSnapshot(`
+      {
+        "forceBtw": false,
+        "prompt": "",
+      }
+    `);
+    });
+    test('multiline message with btw at end', () => {
+        expect(extractBtwSuffix('first line\nsecond line. btw')).toMatchInlineSnapshot(`
+      {
+        "forceBtw": true,
+        "prompt": "first line
+      second line",
+      }
+    `);
     });
 });

package/dist/cli-runner.js

@@ -111,7 +111,11 @@ export async function sendDiscordMessageWithOptionalAttachment({ channelId, prom
     const discordMaxLength = 2000;
     if (prompt.length <= discordMaxLength) {
         return (await rest.post(Routes.channelMessages(channelId), {
-            body: { content: prompt, embeds },
+            body: {
+                content: prompt,
+                embeds,
+                allowed_mentions: { parse: store.getState().allowedMentions },
+            },
         }));
     }
     const preview = prompt.slice(0, 100).replace(/\n/g, ' ');
@@ -158,6 +162,7 @@ export async function sendDiscordMessageWithOptionalAttachment({ channelId, prom
             content: summaryContent,
             attachments: [{ id: 0, filename: 'prompt.md' }],
             embeds,
+            allowed_mentions: { parse: store.getState().allowedMentions },
         }));
         const buffer = fs.readFileSync(tmpFile);
         formData.append('files[0]', new Blob([buffer], { type: 'text/markdown' }), 'prompt.md');
@@ -509,6 +514,7 @@ export async function ensureCommandAvailable({ name, envPathKey, installUnix, in
 }
 // Run opencode upgrade in the background so the user always has the latest version.
 // Spawn caffeinate on macOS to prevent system sleep while bot is running.
+// Uses -s to also prevent sleep on lid close (AC power only, not battery).
 // Uses -w to watch the parent PID so caffeinate self-terminates if kimaki
 // exits for any reason (SIGTERM, crash, process.exit, supervisor stop).
 export function startCaffeinate() {
@@ -516,7 +522,7 @@ export function startCaffeinate() {
         return;
     }
     try {
-        const proc = spawn('caffeinate', ['-i', '-w', String(process.pid)], {
+        const proc = spawn('caffeinate', ['-s', '-w', String(process.pid)], {
             stdio: 'ignore',
             detached: false,
         });

package/dist/cli.js

@@ -44,6 +44,10 @@ cli
     .option('--no-sentry', 'Disable Sentry error reporting')
     .option('--gateway', 'Force gateway mode (use the gateway Kimaki bot instead of a self-hosted bot)')
     .option('--gateway-callback-url <url>', 'After gateway OAuth install, redirect to this URL instead of the default success page (appends ?guild_id=<id>)')
+    .option('--allow-mention <type>', z
+    .array(z.enum(['users', 'roles', 'everyone']))
+    .optional()
+    .describe('Which mention types the bot can trigger (users, roles, everyone). Repeatable. Default: users only.'))
     .option('--enable-skill <name>', z
     .array(z.string())
     .optional()
@@ -140,6 +144,7 @@ cli
             ...(options.disableSync && { syncEnabled: false }),
             ...(enabledSkills.length > 0 && { enabledSkills }),
             ...(disabledSkills.length > 0 && { disabledSkills }),
+            ...(options.allowMention && { allowedMentions: options.allowMention }),
         });
         if (enabledSkills.length > 0) {
             cliLogger.log(`Skill whitelist enabled: only [${enabledSkills.join(', ')}] will be injected`);

package/dist/commands/abort.js

@@ -27,7 +27,7 @@ export async function handleAbortCommand({ command, }) {
         });
         return;
     }
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    await command.deferReply();
     const resolved = await resolveWorkingDirectory({
         channel: channel,
     });

package/dist/commands/model-variant.js

@@ -292,7 +292,7 @@ export async function handleVariantScopeSelectMenu(interaction) {
 async function applyVariant({ interaction, context, variant, scope, contextHash, }) {
     const modelId = context.modelId;
     const variantSuffix = variant ? ` (${variant})` : '';
-    const agentTip = '\n_Tip: create [agent .md files](https://kimaki.dev/model-switching) in .opencode/agent/ for one-command model switching_';
+    const agentTip = '\n_Tip: create [agent .md files](https://kimaki.dev/docs/model-switching) in .opencode/agent/ for one-command model switching_';
     try {
         if (scope === 'session') {
             if (!context.sessionId) {

package/dist/commands/model.js

@@ -728,7 +728,7 @@ export async function handleModelScopeSelectMenu(interaction) {
     const modelDisplay = modelId.split('/')[1] || modelId;
     const variant = context.selectedVariant ?? null;
     const variantSuffix = variant ? ` (${variant})` : '';
-    const agentTip = '\n_Tip: create [agent .md files](https://kimaki.dev/model-switching) in .opencode/agent/ for one-command model switching_';
+    const agentTip = '\n_Tip: create [agent .md files](https://kimaki.dev/docs/model-switching) in .opencode/agent/ for one-command model switching_';
     try {
         if (selectedScope === 'session') {
             if (!context.sessionId) {

package/dist/commands/restart-opencode-server.js

@@ -46,7 +46,7 @@ export async function handleRestartOpencodeServerCommand({ command, appId, }) {
     }
     const { projectDirectory } = resolved;
     // Defer reply since restart may take a moment
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    await command.deferReply();
     // Dispose all runtimes for this directory/channel scope.
     // disposeRuntimesForDirectory aborts active runs, kills listeners, and
     // removes runtimes from the registry. Scoped by channelId so runtimes

package/dist/commands/undo-redo.js

@@ -58,7 +58,7 @@ export async function handleUndoCommand({ command, }) {
         });
         return;
     }
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    await command.deferReply();
     const getClient = await initializeOpencodeForDirectory(projectDirectory);
     if (getClient instanceof Error) {
         await command.editReply(`Failed to undo: ${getClient.message}`);
@@ -209,7 +209,7 @@ export async function handleRedoCommand({ command, }) {
         });
         return;
     }
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    await command.deferReply();
     const getClient = await initializeOpencodeForDirectory(projectDirectory);
     if (getClient instanceof Error) {
         await command.editReply(`Failed to redo: ${getClient.message}`);

package/dist/commands/upgrade.js

@@ -1,13 +1,12 @@
 // /upgrade-and-restart command - Upgrade kimaki to the latest version and restart the bot.
 // Checks npm for a newer version, installs it globally, then spawns a new kimaki process.
 // The new process kills the old one on startup (kimaki's single-instance lock).
-import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { getCurrentVersion, upgrade } from '../upgrade.js';
 import { spawn } from 'node:child_process';
 const logger = createLogger(LogPrefix.CLI);
 export async function handleUpgradeAndRestartCommand({ command, }) {
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    await command.deferReply();
     logger.log('[UPGRADE] /upgrade-and-restart triggered');
     try {
         const currentVersion = getCurrentVersion();

package/dist/discord-bot.js

@@ -10,10 +10,10 @@ import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, sendThreadMessage
 import { getOpencodeSystemMessage, isInjectedPromptMarker, } from './system-message.js';
 import YAML from 'yaml';
 import { getTextAttachments, resolveMentions, } from './message-formatting.js';
-import { extractBtwPrefix } from './btw-prefix-detection.js';
+import { extractBtwSuffix } from './btw-prefix-detection.js';
 import { isVoiceAttachment } from './voice-attachment.js';
 import { forkSessionToBtwThread } from './commands/btw.js';
-import { getChannelReferencePermissionRules, preprocessExistingThreadMessage, preprocessNewThreadMessage, } from './message-preprocessing.js';
+import { extractQueueSuffix, getChannelReferencePermissionRules, preprocessExistingThreadMessage, preprocessNewThreadMessage, } from './message-preprocessing.js';
 import { cancelPendingActionButtons } from './commands/action-buttons.js';
 import { cancelPendingQuestion, hasPendingQuestionForThread } from './commands/ask-question.js';
 import { cancelPendingFileUpload } from './commands/file-upload.js';
@@ -30,6 +30,7 @@ import { markDiscordGatewayReady, stopHranaServer } from './hrana-server.js';
 import { notifyError } from './sentry.js';
 import { flushDebouncedProcessCallbacks } from './debounced-process-flush.js';
 import { startRuntimeIdleSweeper } from './runtime-idle-sweeper.js';
+import { store } from './store.js';
 import { startExternalOpencodeSessionSync, stopExternalOpencodeSessionSync, } from './external-opencode-sync.js';
 export { initDatabase, closeDatabase, getChannelDirectory, } from './database.js';
 export { initializeOpencodeForDirectory } from './opencode.js';
@@ -144,6 +145,7 @@ export async function createDiscordClient() {
     // Read REST API URL lazily so gateway mode can set store.discordBaseUrl
     // after module import but before client creation.
     const restApiUrl = getDiscordRestApiUrl();
+    const { allowedMentions } = store.getState();
     return new Client({
         intents: [
             GatewayIntentBits.Guilds,
@@ -158,6 +160,7 @@ export async function createDiscordClient() {
             Partials.ThreadMember,
         ],
         rest: { api: restApiUrl },
+        allowedMentions: { parse: allowedMentions },
     });
 }
 export async function startDiscordBot({ token, appId, discordClient, useWorktrees, }) {
@@ -455,18 +458,17 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                         return;
                     }
                 }
-                // Raw `btw ` mirrors /btw for fast side-question forks from Discord.
-                // Keep this at ingress instead of preprocess because it must create a
-                // new thread/runtime, not just transform the current prompt.
-                // Voice-transcribed `btw` still goes through normal preprocessing.
-                const btwShortcut = projectDirectory && worktreeInfo?.status !== 'pending'
-                    ? extractBtwPrefix(message.content || '')
+                // `. btw` suffix mirrors /btw for fast side-question forks.
+                // Works like queue: just the word "btw" at the end after punctuation
+                // or newline. The whole message (minus the suffix) becomes the fork prompt.
+                const btwResult = projectDirectory && worktreeInfo?.status !== 'pending'
+                    ? extractBtwSuffix(message.content || '')
                     : null;
-                if (btwShortcut && projectDirectory) {
+                if (btwResult?.forceBtw && projectDirectory) {
                     const result = await forkSessionToBtwThread({
                         sourceThread: thread,
                         projectDirectory,
-                        prompt: btwShortcut.prompt,
+                        prompt: btwResult.prompt,
                         userId: message.author.id,
                         username: message.member?.displayName || message.author.displayName,
                         appId: currentAppId,
@@ -743,6 +745,49 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             }
         }
     });
+    // Handle user message edits to update queued messages.
+    // When a user edits a message that is still waiting in kimaki's local queue,
+    // the queue item is updated with the new content. If the edit removes the
+    // queue suffix, the item is removed from the queue.
+    discordClient.on(Events.MessageUpdate, async (_oldMessage, newMessage) => {
+        try {
+            // Fetch full message if partial (cache miss). Needed for mentions
+            // and content to be fully resolved.
+            const message = newMessage.partial
+                ? await newMessage.fetch().catch(() => null)
+                : newMessage;
+            if (!message)
+                return;
+            if (message.author.bot)
+                return;
+            if (!message.content)
+                return;
+            const channel = message.channel;
+            const isThread = [
+                ChannelType.PublicThread,
+                ChannelType.PrivateThread,
+                ChannelType.AnnouncementThread,
+            ].includes(channel.type);
+            if (!isThread)
+                return;
+            const runtime = getRuntime(channel.id);
+            if (!runtime)
+                return;
+            // Use resolveMentions to match initial preprocessing and preserve
+            // newlines (stripMentions collapses them, breaking final-line queue
+            // suffix detection).
+            const { prompt, forceQueue } = extractQueueSuffix(resolveMentions(message));
+            // If the edit removed the queue suffix, remove the item from the queue.
+            // If the suffix is still present, update the prompt.
+            const result = runtime.updateQueuedMessage(message.id, forceQueue ? prompt : '');
+            if (result.found) {
+                discordLogger.log(`[MESSAGE_EDIT] ${result.removed ? 'Removed' : 'Updated'} queued message ${message.id} in thread ${channel.id}`);
+            }
+        }
+        catch (error) {
+            discordLogger.error('Error handling message update:', error instanceof Error ? error.stack : String(error));
+        }
+    });
     // Handle bot-initiated threads created by `kimaki send` (without --notify-only)
     // Uses JSON embed marker to pass options (start, worktree name)
     discordClient.on(Events.ThreadCreate, async (thread, newlyCreated) => {

package/dist/message-preprocessing.js

@@ -45,7 +45,7 @@ async function fetchAvailableAgents(getClient, directory) {
 // kimaki's local queue (same as /queue command).
 const QUEUE_SUFFIX_RE = /(?:[.!?,;:]|^)\s*queue\.?\s*$|\n\s*queue\.?\s*$/i;
 const REPLIED_MESSAGE_TEXT_LIMIT = 1_000;
-function extractQueueSuffix(prompt) {
+export function extractQueueSuffix(prompt) {
     if (!QUEUE_SUFFIX_RE.test(prompt)) {
         return { prompt, forceQueue: false };
     }

package/dist/opencode-interrupt-plugin.js

@@ -56,6 +56,7 @@ function toPromptParts(parts) {
     }, []);
 }
 const DEFAULT_INTERRUPT_STEP_TIMEOUT_MS = 3_000;
+const POST_ABORT_IDLE_GRACE_MS = 250;
 function getInterruptStepTimeoutMsFromEnv() {
     const raw = process.env['KIMAKI_INTERRUPT_STEP_TIMEOUT_MS'];
     if (!raw) {
@@ -240,7 +241,7 @@ const interruptOpencodeSessionOnUserMessage = async (ctx) => {
                 },
                 timeoutMs: 5_000,
             });
-            const idleWait = state.waitForEvent({
+            const initialIdleWait = state.waitForEvent({
                 match: (event) => {
                     return event.type === 'session.idle' && event.properties.sessionID === sessionID;
                 },
@@ -250,7 +251,18 @@ const interruptOpencodeSessionOnUserMessage = async (ctx) => {
                 path: { id: sessionID },
             });
             await abortedAssistantWait;
-            await idleWait;
+            await initialIdleWait;
+            // OpenCode can emit `session.idle` before the aborted assistant update,
+            // then emit another idle after the cancelled run finishes cleanup. Replaying
+            // on the first idle can enqueue the replay behind the still-settling run.
+            // Some paths only emit the first idle, so wait briefly for a post-abort
+            // idle and then continue rather than dropping the user's interrupt.
+            await state.waitForEvent({
+                match: (event) => {
+                    return event.type === 'session.idle' && event.properties.sessionID === sessionID;
+                },
+                timeoutMs: POST_ABORT_IDLE_GRACE_MS,
+            });
             const currentPending = state.getPending(messageID);
             if (!currentPending || currentPending.started) {
                 state.clearPending(messageID);

package/dist/opencode-interrupt-plugin.test.js

@@ -230,6 +230,10 @@ describe('interruptOpencodeSessionOnUserMessage', () => {
                 parentID: REAL_RATE_LIMIT_CASE.previousMessageID,
             }),
         });
+        await delay({ ms: 1 });
+        await eventHook({
+            event: createSessionIdleEvent({ sessionID: REAL_RATE_LIMIT_CASE.sessionID }),
+        });
         await delay({ ms: 20 });
         expect(abortCalls).toEqual([{ path: { id: REAL_RATE_LIMIT_CASE.sessionID } }]);
         expect(promptAsyncCalls).toEqual([
@@ -326,7 +330,10 @@ describe('interruptOpencodeSessionOnUserMessage', () => {
         await chatHook({ sessionID, messageID: userMsgID }, createChatOutput({ sessionID, messageID: userMsgID }));
         // 3. Timeout fires (20ms), plugin runs handleUnsentTimeout
         await delay({ ms: 30 });
-        // 4. Simulate abort completing (error + idle from opencode)
+        // 4. Simulate abort completing. OpenCode can emit an idle event before the
+        //    aborted assistant update, then emit another idle after cleanup settles.
+        //    Replaying before that post-abort idle can leave the replayed message
+        //    queued behind the cancelled run.
         await eventHook({ event: createSessionErrorEvent({ sessionID }) });
         await eventHook({ event: createSessionIdleEvent({ sessionID }) });
         await eventHook({
@@ -339,6 +346,10 @@ describe('interruptOpencodeSessionOnUserMessage', () => {
         await delay({ ms: 20 });
         // 5. Verify plugin aborted the session
         expect(abortCalls).toEqual([{ path: { id: sessionID } }]);
+        expect(promptAsyncCalls).toEqual([]);
+        await delay({ ms: 1 });
+        await eventHook({ event: createSessionIdleEvent({ sessionID }) });
+        await delay({ ms: 20 });
         // 6. Recovery should replay the queued message itself, not an empty
         //    resume prompt. This preserves the original messageID + parts after
         //    session.abort() clears OpenCode's internal prompt queue.
@@ -383,8 +394,8 @@ describe('interruptOpencodeSessionOnUserMessage', () => {
             messageID: REAL_SLEEP_INTERRUPT_CASE.interruptingMessageID,
         }));
         await delay({ ms: 30 });
-        await eventHook({ event: REAL_SLEEP_INTERRUPT_CASE.idleEvent });
         await eventHook({ event: REAL_SLEEP_INTERRUPT_CASE.abortErrorEvent });
+        await eventHook({ event: REAL_SLEEP_INTERRUPT_CASE.idleEvent });
         await eventHook({
             event: createAssistantAbortedEvent({
                 sessionID: REAL_SLEEP_INTERRUPT_CASE.sessionID,
@@ -394,6 +405,10 @@ describe('interruptOpencodeSessionOnUserMessage', () => {
         });
         await delay({ ms: 20 });
         expect(abortCalls).toEqual([{ path: { id: REAL_SLEEP_INTERRUPT_CASE.sessionID } }]);
+        expect(promptAsyncCalls).toEqual([]);
+        await delay({ ms: 1 });
+        await eventHook({ event: REAL_SLEEP_INTERRUPT_CASE.idleEvent });
+        await delay({ ms: 20 });
         expect(promptAsyncCalls).toEqual([
             {
                 path: { id: REAL_SLEEP_INTERRUPT_CASE.sessionID },
@@ -440,8 +455,8 @@ describe('interruptOpencodeSessionOnUserMessage', () => {
         });
         await delay({ ms: 10 });
         expect(abortCalls).toEqual([{ path: { id: sessionID } }]);
-        await eventHook({ event: createSessionIdleEvent({ sessionID }) });
         await eventHook({ event: createSessionErrorEvent({ sessionID }) });
+        await eventHook({ event: createSessionIdleEvent({ sessionID }) });
         await eventHook({
             event: createAssistantAbortedEvent({
                 sessionID,
@@ -450,6 +465,10 @@ describe('interruptOpencodeSessionOnUserMessage', () => {
             }),
         });
         await delay({ ms: 20 });
+        expect(promptAsyncCalls).toEqual([]);
+        await delay({ ms: 1 });
+        await eventHook({ event: createSessionIdleEvent({ sessionID }) });
+        await delay({ ms: 20 });
         expect(promptAsyncCalls).toEqual([
             {
                 path: { id: sessionID },

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

@@ -257,7 +257,7 @@ describe('queue advanced: /model with interrupt recovery', () => {
         **Deterministic Provider** / **deterministic-v3**
         \`deterministic-provider/deterministic-v3\`
         _Restarting current request with new model..._
-        _Tip: create [agent .md files](https://kimaki.dev/model-switching) in .opencode/agent/ for one-command model switching_
+        _Tip: create [agent .md files](https://kimaki.dev/docs/model-switching) in .opencode/agent/ for one-command model switching_
         --- from: user (queue-model-switch-tester)
         PLUGIN_TIMEOUT_SLEEP_MARKER
         --- from: assistant (TestBot)

package/dist/session-handler/agent-utils.js

@@ -1,9 +1,14 @@
 // Agent preference resolution utility.
 // Validates agent preferences against the OpenCode API.
+// When a requested agent is not found, we fall back to the default agent
+// instead of throwing. This handles stale agent preferences from CLI send
+// commands or database references to agents that were removed from config.
 import * as errore from 'errore';
 import { getSessionAgent, getSessionModel, getChannelAgent, } from '../database.js';
+import { createLogger } from '../logger.js';
 import {} from '../opencode.js';
 import {} from '../system-message.js';
+const agentLogger = createLogger('agent');
 export async function resolveValidatedAgentPreference({ agent, sessionId, channelId, getClient, directory, }) {
     const agentPreference = await (async () => {
         if (agent) {
@@ -55,13 +60,8 @@ export async function resolveValidatedAgentPreference({ agent, sessionId, channe
     if (hasAgent) {
         return { agentPreference, agents };
     }
-    const availableAgentNames = availableAgents
-        .map((availableAgent) => {
-        return availableAgent.name;
-    })
-        .slice(0, 20);
-    const availableAgentsMessage = availableAgentNames.length > 0
-        ? `Available agents: ${availableAgentNames.join(', ')}`
-        : 'No agents are available in this project.';
-    throw new Error(`Agent "${agentPreference}" not found. ${availableAgentsMessage} Use /agent to choose a valid one.`);
+    // Fall back to default agent instead of erroring. This handles stale
+    // preferences from CLI send commands or removed agents in config.
+    agentLogger.warn(`Agent "${agentPreference}" not found, falling back to default agent`);
+    return { agentPreference: undefined, agents };
 }

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

@@ -131,6 +131,35 @@ export function removeQueueItemAtPosition(threadId, position) {
     });
     return removedItem;
 }
+/**
+ * Find a queued item by its Discord source message ID and apply an updater.
+ * If the updater returns null, the item is removed from the queue.
+ * Returns the original (pre-update) item, or undefined if not found.
+ */
+export function updateQueueItemBySourceMessageId(threadId, sourceMessageId, updater) {
+    let originalItem;
+    store.setState((s) => {
+        const t = s.threads.get(threadId);
+        if (!t)
+            return s;
+        const index = t.queueItems.findIndex((item) => {
+            return item.sourceMessageId === sourceMessageId;
+        });
+        if (index === -1)
+            return s;
+        originalItem = t.queueItems[index];
+        const updated = updater(originalItem);
+        const newThreads = new Map(s.threads);
+        newThreads.set(threadId, {
+            ...t,
+            queueItems: updated === null
+                ? t.queueItems.filter((_, i) => i !== index)
+                : t.queueItems.map((item, i) => (i === index ? updated : item)),
+        });
+        return { threads: newThreads };
+    });
+    return originalItem;
+}
 // ── Queries ──────────────────────────────────────────────────────
 export function getThreadState(threadId) {
     return store.getState().threads.get(threadId);