kimaki 0.11.0 → 0.13.0

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

@@ -19,7 +19,7 @@ import { buildDeterministicOpencodeConfig, } from 'opencode-deterministic-provid
 import { setDataDir } from './config.js';
 import { store } from './store.js';
 import { startDiscordBot } from './discord-bot.js';
-import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChannelVerbosity, setChannelAgent, setChannelModel, } from './database.js';
+import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChannelVerbosity, setChannelAgent, setChannelModel, getThreadSession, getSessionAgent, getChannelAgent, } from './database.js';
 import { getDb } from './db.js';
 import * as orm from 'drizzle-orm';
 import * as schema from './schema.js';
@@ -258,6 +258,10 @@ describe('agent model resolution', () => {
                 description: `Switch to ${agentName} agent`,
             }))
                 .setDMPermission(false)
+                .addStringOption((opt) => opt
+                .setName('prompt')
+                .setDescription('Send a prompt with this agent')
+                .setRequired(false))
                 .toJSON();
         });
         const rest = new REST({ version: '10', api: discord.restUrl }).setToken(discord.botToken);
@@ -681,6 +685,92 @@ describe('agent model resolution', () => {
         expect(secondFooter.content).toContain(DEFAULT_MODEL);
         expect(secondFooter.content).not.toContain(AGENT_MODEL);
     }, 20_000);
+    test('/plan-agent with prompt starts a session with the plan agent', async () => {
+        await setChannelAgent(TEXT_CHANNEL_ID, 'test-agent');
+        const prompt = 'Reply with exactly: inline-plan-agent-msg';
+        const { id: interactionId } = await discord
+            .channel(TEXT_CHANNEL_ID)
+            .user(TEST_USER_ID)
+            .runSlashCommand({
+            name: 'plan-agent',
+            options: [{ name: 'prompt', type: 3, value: prompt }],
+        });
+        await discord
+            .channel(TEXT_CHANNEL_ID)
+            .waitForInteractionAck({ interactionId, timeout: 4_000 });
+        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === prompt;
+            },
+        });
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: discord.botUserId,
+        });
+        const sessionId = await getThreadSession(thread.id);
+        expect(sessionId).toBeDefined();
+        expect(sessionId ? await getSessionAgent(sessionId) : undefined).toBe('plan');
+        expect(await getChannelAgent(TEXT_CHANNEL_ID)).toBe('test-agent');
+        expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+        "--- from: assistant (TestBot)
+        » **agent-model-tester** (plan): Reply with exactly: inline-plan-agent-msg
+        *using deterministic-provider/plan-model-v2 ⋅ plan*
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
+      `);
+    }, 20_000);
+    test('/plan-agent with prompt in an existing thread changes the session agent', async () => {
+        await setChannelAgent(TEXT_CHANNEL_ID, 'test-agent');
+        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: inline-existing-first-msg',
+        });
+        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: inline-existing-first-msg';
+            },
+        });
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: discord.botUserId,
+        });
+        const prompt = 'Reply with exactly: inline-existing-plan-msg';
+        const th = discord.thread(thread.id);
+        const { id: interactionId } = await th.user(TEST_USER_ID).runSlashCommand({
+            name: 'plan-agent',
+            options: [{ name: 'prompt', type: 3, value: prompt }],
+        });
+        await th.waitForInteractionAck({ interactionId, timeout: 4_000 });
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'inline-existing-plan-msg',
+            afterAuthorId: discord.botUserId,
+        });
+        const sessionId = await getThreadSession(thread.id);
+        expect(sessionId).toBeDefined();
+        expect(sessionId ? await getSessionAgent(sessionId) : undefined).toBe('plan');
+        expect(await getChannelAgent(TEXT_CHANNEL_ID)).toBe('test-agent');
+        expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (agent-model-tester)
+        Reply with exactly: inline-existing-first-msg
+        --- from: assistant (TestBot)
+        *using deterministic-provider/agent-model-v2 ⋅ test-agent*
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
+        » **agent-model-tester** (plan): Reply with exactly: inline-existing-plan-msg
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***"
+      `);
+    }, 20_000);
     test('/plan-agent inside a thread switches the model for that thread', async () => {
         // 1. Start with test-agent on the channel
         await setChannelAgent(TEXT_CHANNEL_ID, 'test-agent');

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,
         });
@@ -938,16 +944,34 @@ export async function run({ restartOnboarding, addChannels, useWorktrees, enable
     startCaffeinate();
     const forceRestartOnboarding = Boolean(restartOnboarding);
     const forceGateway = Boolean(gateway);
-    // Step 0: Ensure bun is installed. OpenCode is downloaded on first run
-    // to ~/.kimaki/bin/ (pinned version), so no install check is needed.
-    await ensureCommandAvailable({
-        name: 'bun',
-        envPathKey: 'BUN_PATH',
-        installUnix: 'curl -fsSL https://bun.sh/install | bash',
-        installWindows: 'irm bun.sh/install.ps1 | iex',
-        possiblePathsUnix: ['~/.bun/bin/bun', '/usr/local/bin/bun'],
-        possiblePathsWindows: ['~\\.bun\\bin\\bun.exe'],
-    });
+    // Step 0: Ensure opencode and bun are installed
+    await Promise.all([
+        ensureCommandAvailable({
+            name: 'opencode',
+            envPathKey: 'OPENCODE_PATH',
+            installUnix: 'curl -fsSL https://opencode.ai/install | bash',
+            installWindows: 'irm https://opencode.ai/install.ps1 | iex',
+            possiblePathsUnix: [
+                '~/.local/bin/opencode',
+                '~/.opencode/bin/opencode',
+                '/usr/local/bin/opencode',
+                '/opt/opencode/bin/opencode',
+            ],
+            possiblePathsWindows: [
+                '~\\.local\\bin\\opencode.exe',
+                '~\\AppData\\Local\\opencode\\opencode.exe',
+                '~\\.opencode\\bin\\opencode.exe',
+            ],
+        }),
+        ensureCommandAvailable({
+            name: 'bun',
+            envPathKey: 'BUN_PATH',
+            installUnix: 'curl -fsSL https://bun.sh/install | bash',
+            installWindows: 'irm bun.sh/install.ps1 | iex',
+            possiblePathsUnix: ['~/.bun/bin/bun', '/usr/local/bin/bun'],
+            possiblePathsWindows: ['~\\.bun\\bin\\bun.exe'],
+        }),
+    ]);
     void backgroundUpgradeKimaki();
     // Start in-process Hrana server before database init. Required for the bot
     // process because it serves as both the DB server and the single-instance

package/dist/cli.js

@@ -40,9 +40,14 @@ cli
     .option('--no-critique', 'Disable automatic diff upload to critique.work in system prompts')
     .option('--auto-restart', 'Automatically restart the bot on crash or OOM kill')
     .option('--allow-all-users', 'Allow all Discord users to start sessions without needing Kimaki role or admin permissions (no-kimaki role still blocks)')
+    .option('--disable-sync', 'Disable background sync of external OpenCode sessions into Discord')
     .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()
@@ -136,8 +141,10 @@ cli
             ...(options.mentionMode && { defaultMentionMode: true }),
             ...(options.noCritique && { critiqueEnabled: false }),
             ...(options.allowAllUsers && { allowAllUsers: true }),
+            ...(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`);
@@ -157,6 +164,9 @@ cli
         if (options.noCritique) {
             cliLogger.log('Critique disabled: diffs will not be auto-uploaded to critique.work');
         }
+        if (options.disableSync) {
+            cliLogger.log('Background sync disabled: external OpenCode sessions will not appear in Discord');
+        }
         if (options.noSentry) {
             process.env.KIMAKI_SENTRY_DISABLED = '1';
             cliLogger.log('Sentry error reporting disabled (--no-sentry)');

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/agent.js

@@ -1,7 +1,7 @@
 // /agent command - Set the preferred agent for this channel or session.
 // Also provides quick agent commands like /plan-agent, /build-agent that switch instantly.
 // When a prompt is provided to a quick agent command (e.g. /plan-agent "fix the bug"),
-// the prompt is sent as a one-shot with that agent without switching the persistent preference.
+// the prompt is sent with that agent and the session keeps that agent afterwards.
 import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, ThreadAutoArchiveDuration, MessageFlags, } from 'discord.js';
 import crypto from 'node:crypto';
 import { setChannelAgent, setSessionAgent, clearSessionModel, getThreadSession, getSessionAgent, getChannelAgent, } from '../database.js';
@@ -162,7 +162,7 @@ export async function setAgentForContext({ context, agentName, }) {
     }
 }
 export async function handleAgentCommand({ interaction, appId, }) {
-    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+    await interaction.deferReply();
     const context = await resolveAgentCommandContext({ interaction, appId });
     if (!context) {
         return;
@@ -290,13 +290,12 @@ export async function handleAgentSelectMenu(interaction) {
 export async function handleQuickAgentCommand({ command, appId, }) {
     const fallbackAgentName = command.commandName.replace(/-agent$/, '');
     const prompt = command.options.getString('prompt') || undefined;
-    // One-shot prompt mode: send the prompt with a temporary agent override
-    // without changing the persistent agent preference.
+    // Prompt mode: send the prompt with this agent immediately.
     if (prompt) {
         return handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, prompt });
     }
     // No prompt: switch the persistent agent preference (original behavior).
-    await command.deferReply({ flags: MessageFlags.Ephemeral });
+    await command.deferReply();
     const context = await resolveAgentCommandContext({
         interaction: command,
         appId,
@@ -363,10 +362,10 @@ export async function handleQuickAgentCommand({ command, appId, }) {
     }
 }
 /**
- * Handle one-shot prompt mode: send a prompt with a temporary agent override.
- * In a thread: enqueue the prompt with the agent override on the existing session.
- * In a channel: create a new thread and enqueue the prompt with the agent override.
- * Neither case changes the persistent agent preference.
+ * Handle prompt mode: send a prompt with the requested agent.
+ * In a thread: enqueue the prompt on the existing session and switch that session.
+ * In a channel: create a new thread whose session starts with the requested agent.
+ * Channel-level preferences are not changed.
  */
 async function handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, prompt, }) {
     const channel = command.channel;
@@ -386,7 +385,7 @@ async function handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, p
     ].includes(channel.type);
     const displayText = `${prompt.slice(0, 1000)}${prompt.length > 1000 ? '...' : ''}`;
     if (isThread) {
-        // In a thread: enqueue the prompt on the existing session with agent override.
+        // In a thread: enqueue the prompt and switch the existing session to this agent.
         const thread = channel;
         const resolved = await resolveWorkingDirectory({ channel: thread });
         if (!resolved) {
@@ -419,9 +418,8 @@ async function handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, p
         });
     }
     else if (channel.type === ChannelType.GuildText) {
-        // In a channel: create a new thread and enqueue with the agent override.
-        const textChannel = channel;
-        const metadata = await getKimakiMetadata(textChannel);
+        // In a channel: create a new thread and enqueue with the requested agent.
+        const metadata = await getKimakiMetadata(channel);
         const projectDirectory = metadata.projectDirectory;
         if (!projectDirectory) {
             await command.reply({
@@ -431,14 +429,14 @@ async function handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, p
             return;
         }
         await command.deferReply();
-        const starterMessage = await textChannel.send({
+        const starterMessage = await channel.send({
             content: `» **${command.user.displayName}** (${resolvedAgentName}): ${displayText}`,
             flags: SILENT_MESSAGE_FLAGS,
         });
         const thread = await starterMessage.startThread({
             name: prompt.slice(0, 80),
             autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
-            reason: `One-shot ${resolvedAgentName} agent prompt`,
+            reason: `${resolvedAgentName} agent prompt`,
         });
         await thread.members.add(command.user.id);
         await command.editReply(`Sent with **${resolvedAgentName}** agent in ${thread.toString()}`);
@@ -447,7 +445,7 @@ async function handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, p
             thread,
             projectDirectory,
             sdkDirectory: projectDirectory,
-            channelId: textChannel.id,
+            channelId: channel.id,
             appId,
         });
         await runtime.enqueueIncoming({

package/dist/commands/mention-mode.js

@@ -38,6 +38,5 @@ export async function handleToggleMentionModeCommand({ command, }) {
         content: nextEnabled
             ? `Mention mode **enabled** for this channel.\nThe bot will only start new sessions when @mentioned.\nMessages in existing threads are not affected.`
             : `Mention mode **disabled** for this channel.\nThe bot will respond to all messages in **#${channel.name}**.`,
-        flags: MessageFlags.Ephemeral,
     });
 }

package/dist/commands/model-variant.js

@@ -40,7 +40,7 @@ function formatSourceLabel(info) {
     }
 }
 export async function handleModelVariantCommand({ interaction, appId, }) {
-    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+    await interaction.deferReply();
     const channel = interaction.channel;
     if (!channel) {
         await interaction.editReply({
@@ -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://github.com/remorses/kimaki/blob/main/docs/model-switching.md) 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) {