kimaki 0.11.0 → 0.12.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/cli-runner.js

@@ -938,16 +938,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,6 +40,7 @@ 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>)')
@@ -136,6 +137,7 @@ 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 }),
         });
@@ -157,6 +159,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/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/model-switching) in .opencode/agent/ for one-command model switching_';
     try {
         if (scope === 'session') {
             if (!context.sessionId) {

package/dist/commands/model.js

@@ -11,6 +11,20 @@ import { createLogger, LogPrefix } from '../logger.js';
 import * as errore from 'errore';
 import { buildPaginatedOptions, parsePaginationValue } from './paginated-select.js';
 const modelLogger = createLogger(LogPrefix.MODEL);
+function buildSafeSelectOption({ label, value, description, }) {
+    const trimmedLabel = label?.trim();
+    const trimmedValue = value?.trim();
+    const safeLabel = (trimmedLabel || trimmedValue || 'Unknown').slice(0, 100);
+    const safeValue = trimmedValue || trimmedLabel || '';
+    if (!safeLabel || !safeValue) {
+        return undefined;
+    }
+    return {
+        label: safeLabel,
+        value: safeValue,
+        description: description?.slice(0, 100),
+    };
+}
 // Store context by hash to avoid customId length limits (Discord max: 100 chars).
 // Entries are TTL'd to prevent unbounded growth when users open /model and never
 // interact with the select menu.
@@ -172,7 +186,7 @@ export async function getCurrentModelInfo({ sessionId, channelId, appId, agentPr
 export async function handleModelCommand({ interaction, appId, }) {
     modelLogger.log('[MODEL] handleModelCommand called');
     // Defer reply immediately to avoid 3-second timeout
-    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+    await interaction.deferReply();
     modelLogger.log('[MODEL] Deferred reply');
     const channel = interaction.channel;
     if (!channel) {
@@ -307,15 +321,16 @@ export async function handleModelCommand({ interaction, appId, }) {
         const contextHash = crypto.randomBytes(8).toString('hex');
         setModelContext(contextHash, context);
         const allProviderOptions = [...availableProviders]
-            .sort((a, b) => a.name.localeCompare(b.name))
+            .sort((a, b) => (a.name || a.id || '').localeCompare(b.name || b.id || ''))
             .map((provider) => {
             const modelCount = Object.keys(provider.models || {}).length;
-            return {
-                label: provider.name.slice(0, 100),
+            return buildSafeSelectOption({
+                label: provider.name,
                 value: provider.id,
-                description: `${modelCount} model${modelCount !== 1 ? 's' : ''} available`.slice(0, 100),
-            };
-        });
+                description: `${modelCount} model${modelCount !== 1 ? 's' : ''} available`,
+            });
+        })
+            .filter((option) => !!option);
         const { options } = buildPaginatedOptions({
             allOptions: allProviderOptions,
             page: 0,
@@ -383,15 +398,16 @@ export async function handleProviderSelectMenu(interaction) {
         const { all: allProviders, connected } = providersResponse.data;
         const availableProviders = allProviders.filter((p) => connected.includes(p.id));
         const allProviderOptions = [...availableProviders]
-            .sort((a, b) => a.name.localeCompare(b.name))
+            .sort((a, b) => (a.name || a.id || '').localeCompare(b.name || b.id || ''))
             .map((p) => {
             const modelCount = Object.keys(p.models || {}).length;
-            return {
-                label: p.name.slice(0, 100),
+            return buildSafeSelectOption({
+                label: p.name,
                 value: p.id,
-                description: `${modelCount} model${modelCount !== 1 ? 's' : ''} available`.slice(0, 100),
-            };
-        });
+                description: `${modelCount} model${modelCount !== 1 ? 's' : ''} available`,
+            });
+        })
+            .filter((option) => !!option);
         const { options } = buildPaginatedOptions({ allOptions: allProviderOptions, page: providerNavPage });
         const selectMenu = new StringSelectMenuBuilder()
             .setCustomId(`model_provider:${contextHash}`)
@@ -434,10 +450,11 @@ export async function handleProviderSelectMenu(interaction) {
         const models = Object.entries(provider.models || {})
             .map(([modelId, model]) => ({
             id: modelId,
-            name: model.name,
+            name: model.name || modelId,
             releaseDate: model.release_date,
         }))
-            .sort((a, b) => a.name.localeCompare(b.name));
+            .filter((model) => model.id && model.name)
+            .sort((a, b) => (a.name || a.id || '').localeCompare(b.name || b.id || ''));
         if (models.length === 0) {
             await interaction.editReply({
                 content: `No models available for ${provider.name}`,
@@ -447,19 +464,21 @@ export async function handleProviderSelectMenu(interaction) {
         }
         // Update context with provider info and reuse the same hash
         context.providerId = selectedProviderId;
-        context.providerName = provider.name;
+        context.providerName = provider.name?.trim() || provider.id;
         context.modelPage = 0;
         setModelContext(contextHash, context);
-        const allModelOptions = models.map((model) => {
+        const allModelOptions = models
+            .map((model) => {
             const dateStr = model.releaseDate
                 ? new Date(model.releaseDate).toLocaleDateString()
                 : 'Unknown date';
-            return {
-                label: model.name.slice(0, 100),
+            return buildSafeSelectOption({
+                label: model.name,
                 value: model.id,
-                description: dateStr.slice(0, 100),
-            };
-        });
+                description: dateStr,
+            });
+        })
+            .filter((option) => !!option);
         const { options } = buildPaginatedOptions({
             allOptions: allModelOptions,
             page: 0,
@@ -527,13 +546,14 @@ export async function handleModelSelectMenu(interaction) {
             return;
         }
         const allModelOptions = Object.entries(provider.models || {})
-            .map(([modelId, model]) => ({
-            label: model.name.slice(0, 100),
+            .map(([modelId, model]) => buildSafeSelectOption({
+            label: model.name || modelId,
             value: modelId,
-            description: (model.release_date
+            description: model.release_date
                 ? new Date(model.release_date).toLocaleDateString()
-                : 'Unknown date').slice(0, 100),
+                : 'Unknown date',
         }))
+            .filter((option) => !!option)
             .sort((a, b) => a.label.localeCompare(b.label));
         const { options } = buildPaginatedOptions({ allOptions: allModelOptions, page: modelNavPage });
         const selectMenu = new StringSelectMenuBuilder()
@@ -708,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://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/model-switching) in .opencode/agent/ for one-command model switching_';
     try {
         if (selectedScope === 'session') {
             if (!context.sessionId) {

package/dist/commands/unset-model.js

@@ -1,5 +1,5 @@
 // /unset-model-override command - Remove model overrides and use default instead.
-import { ChatInputCommandInteraction, ChannelType, MessageFlags, } from 'discord.js';
+import { ChatInputCommandInteraction, ChannelType, } from 'discord.js';
 import { getChannelModel, getSessionModel, getThreadSession, clearSessionModel, } from '../database.js';
 import { getDb } from '../db.js';
 import * as orm from 'drizzle-orm';
@@ -35,7 +35,7 @@ function formatModelSource(type, agentName) {
  */
 export async function handleUnsetModelCommand({ interaction, appId, }) {
     unsetModelLogger.log('[UNSET-MODEL] handleUnsetModelCommand called');
-    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+    await interaction.deferReply();
     const channel = interaction.channel;
     if (!channel) {
         await interaction.editReply({

package/dist/commands/verbosity.js

@@ -85,7 +85,6 @@ export async function handleVerbosityCommand({ command, }) {
     await command.reply({
         content: `**Verbosity**\nCurrent: \`${currentLevel}\` (${source})`,
         components: [actionRow],
-        flags: MessageFlags.Ephemeral,
     });
 }
 /**

package/dist/commands/worktree-settings.js

@@ -37,6 +37,5 @@ export async function handleToggleWorktreesCommand({ command, }) {
         content: nextEnabled
             ? `Worktrees **enabled** for this channel.\n\nNew sessions started from messages in **#${channel.name}** will now automatically create git worktrees.\n\nNew setting for **#${channel.name}**: **enabled**.`
             : `Worktrees **disabled** for this channel.\n\nNew sessions started from messages in **#${channel.name}** will use the main project directory.\n\nNew setting for **#${channel.name}**: **disabled**.`,
-        flags: MessageFlags.Ephemeral,
     });
 }

package/dist/discord-bot.js

@@ -6,7 +6,7 @@ import { stopOpencodeServer, } from './opencode.js';
 import { formatAutoWorktreeName, createWorktreeInBackground, worktreeCreatingMessage } from './commands/new-worktree.js';
 import { resolveSessionWorkingDirectory, git, isGitRepositoryRoot } from './worktrees.js';
 import { WORKTREE_PREFIX } from './commands/merge-worktree.js';
-import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, sendThreadMessage, SILENT_MESSAGE_FLAGS, NOTIFY_MESSAGE_FLAGS, reactToThread, stripMentions, hasKimakiBotPermission, hasNoKimakiRole, } from './discord-utils.js';
+import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, sendThreadMessage, SILENT_MESSAGE_FLAGS, NOTIFY_MESSAGE_FLAGS, reactToThread, stripMentions, hasKimakiBotPermission, hasNoKimakiRole, resolveGuildMessageMember, } from './discord-utils.js';
 import { getOpencodeSystemMessage, isInjectedPromptMarker, } from './system-message.js';
 import YAML from 'yaml';
 import { getTextAttachments, resolveMentions, } from './message-formatting.js';
@@ -304,7 +304,8 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             // still need Kimaki permission so multi-agent orchestration stays opt-in.
             const isInjectedSelfBotMessage = isCliInjectedPrompt && message.author?.id === discordClient.user?.id;
             if (message.author?.bot && !isInjectedSelfBotMessage) {
-                if (!hasKimakiBotPermission(message.member)) {
+                const member = await resolveGuildMessageMember(message);
+                if (!hasKimakiBotPermission(member, message.guild)) {
                     return;
                 }
             }
@@ -343,15 +344,19 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     }
                 }
             }
-            if (!isCliInjectedPrompt && message.guild && message.member) {
-                if (hasNoKimakiRole(message.member)) {
+            if (!isCliInjectedPrompt && message.guild) {
+                const member = await resolveGuildMessageMember(message);
+                if (!member) {
+                    return;
+                }
+                if (hasNoKimakiRole(member)) {
                     await message.reply({
                         content: `You have the **no-kimaki** role which blocks bot access.\nRemove this role to use Kimaki.`,
                         flags: SILENT_MESSAGE_FLAGS,
                     });
                     return;
                 }
-                if (!hasKimakiBotPermission(message.member)) {
+                if (!hasKimakiBotPermission(member, message.guild)) {
                     await message.reply({
                         content: `You don't have permission to start sessions.\nTo use Kimaki, ask a server admin to give you the **Kimaki** role.`,
                         flags: SILENT_MESSAGE_FLAGS,

package/dist/discord-command-registration.js

@@ -395,7 +395,7 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .setDMPermission(false)
             .addStringOption((opt) => opt
             .setName('prompt')
-            .setDescription('Send a one-shot prompt with this agent without switching')
+            .setDescription('Send a prompt with this agent')
             .setRequired(false))
             .toJSON());
     }

package/dist/discord-utils.js

@@ -72,6 +72,20 @@ export function hasKimakiAdminPermission(member, guild) {
     const hasKimakiRole = hasRoleByName(member, 'kimaki', guild);
     return isOwner || isAdmin || canManageServer || hasKimakiRole;
 }
+export async function resolveGuildMessageMember(message) {
+    if (!message.guild)
+        return null;
+    if (message.member)
+        return message.member;
+    const fetchedMember = await message.guild.members
+        .fetch(message.author.id)
+        .catch((e) => new Error('Failed to fetch guild member', { cause: e }));
+    if (fetchedMember instanceof Error) {
+        discordLogger.warn(`[PERMISSION] Denying message ${message.id}: ${fetchedMember.message}`);
+        return null;
+    }
+    return fetchedMember;
+}
 function hasRoleByName(member, roleName, guild) {
     const target = roleName.toLowerCase();
     if (member instanceof GuildMember) {

package/dist/discord-utils.test.js

@@ -1,6 +1,6 @@
 import { PermissionsBitField } from 'discord.js';
 import { afterEach, describe, expect, test } from 'vitest';
-import { hasKimakiAdminPermission, hasKimakiBotPermission, splitMarkdownForDiscord } from './discord-utils.js';
+import { hasKimakiAdminPermission, hasKimakiBotPermission, resolveGuildMessageMember, splitMarkdownForDiscord, } from './discord-utils.js';
 import { store } from './store.js';
 describe('splitMarkdownForDiscord', () => {
     test('never returns chunks over the max length with code fences', () => {
@@ -198,3 +198,53 @@ describe('hasKimakiAdminPermission', () => {
         expect(hasKimakiAdminPermission(member, guild)).toBe(true);
     });
 });
+describe('resolveGuildMessageMember', () => {
+    test('uses hydrated message member without fetching', async () => {
+        const member = { id: 'member-id' };
+        const message = {
+            guild: {
+                members: {
+                    fetch() {
+                        throw new Error('should not fetch');
+                    },
+                },
+            },
+            member,
+            author: { id: 'member-id' },
+            id: 'message-id',
+        };
+        await expect(resolveGuildMessageMember(message)).resolves.toBe(member);
+    });
+    test('fetches missing guild message member', async () => {
+        const member = { id: 'member-id' };
+        const message = {
+            guild: {
+                members: {
+                    fetch(id) {
+                        expect(id).toBe('member-id');
+                        return Promise.resolve(member);
+                    },
+                },
+            },
+            member: null,
+            author: { id: 'member-id' },
+            id: 'message-id',
+        };
+        await expect(resolveGuildMessageMember(message)).resolves.toBe(member);
+    });
+    test('denies when missing guild message member cannot be fetched', async () => {
+        const message = {
+            guild: {
+                members: {
+                    fetch() {
+                        return Promise.reject(new Error('missing member'));
+                    },
+                },
+            },
+            member: null,
+            author: { id: 'member-id' },
+            id: 'message-id',
+        };
+        await expect(resolveGuildMessageMember(message)).resolves.toBe(null);
+    });
+});