kimaki 0.10.2 → 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-commands/misc.js

@@ -1,4 +1,4 @@
-// File upload terminal command for sharing local files into Discord threads.
+// File upload and TTS terminal commands for sharing local files into Discord threads.
 import { goke } from 'goke';
 import { z } from 'zod';
 import { note } from '@clack/prompts';
@@ -11,7 +11,7 @@ import { fileURLToPath } from 'node:url';
 import { spawn, execSync } from 'node:child_process';
 import { createLogger, LogPrefix, initLogFile } from '../logger.js';
 import { createDiscordClient, initDatabase, getChannelDirectory, initializeOpencodeForDirectory, createProjectChannels } from '../discord-bot.js';
-import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
+import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory, getAnyAudioApiKey } from '../database.js';
 import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';
@@ -73,4 +73,78 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
 });
+cli
+    .command('tts [text]', 'Generate speech audio from text. Reads from stdin if no text given.')
+    .option('-o, --output [path]', 'Output file path (default: speech.mp3)')
+    .option('-v, --voice [voice]', 'Voice ID, defaults to alloy (OpenAI) or Kore (Gemini)')
+    .option('-i, --instructions [text]', 'Style instructions, e.g. "Speak calmly" (OpenAI only)')
+    .option('--speed [speed]', 'Speed multiplier 0.25-4.0 (OpenAI only)')
+    .option('-p, --provider [provider]', 'openai or gemini (auto-detected from key)')
+    .option('-k, --api-key [key]', 'API key (falls back to stored key or env var)')
+    .action(async (text, options) => {
+    const { generateSpeech } = await import('../voice.js');
+    // Read from stdin if no positional text argument
+    if (!text) {
+        if (process.stdin.isTTY) {
+            cliLogger.error('No text provided. Pass text as argument or pipe via stdin.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+        }
+        text = Buffer.concat(chunks).toString('utf-8').trim();
+        if (!text) {
+            cliLogger.error('Empty input from stdin.');
+            process.exit(EXIT_NO_RESTART);
+        }
+    }
+    await initDatabase();
+    // Resolve API key: flag → DB → env
+    let apiKey = options.apiKey;
+    let provider = options.provider === 'openai' || options.provider === 'gemini'
+        ? options.provider
+        : undefined;
+    if (!apiKey) {
+        const stored = await getAnyAudioApiKey();
+        if (stored) {
+            apiKey = stored.apiKey;
+            provider = provider || stored.provider;
+        }
+    }
+    if (!apiKey) {
+        if (process.env.OPENAI_API_KEY) {
+            apiKey = process.env.OPENAI_API_KEY;
+            provider = provider || 'openai';
+        }
+        else if (process.env.GEMINI_API_KEY) {
+            apiKey = process.env.GEMINI_API_KEY;
+            provider = provider || 'gemini';
+        }
+    }
+    if (!apiKey) {
+        cliLogger.error('No API key found. Use --api-key, set OPENAI_API_KEY/GEMINI_API_KEY, or run /transcription-key in Discord.');
+        process.exit(EXIT_NO_RESTART);
+    }
+    const speed = options.speed ? Number(options.speed) : 1.25;
+    cliLogger.log(`Generating speech with ${provider || 'auto-detected provider'}...`);
+    const result = await generateSpeech({
+        text,
+        voice: options.voice || undefined,
+        apiKey,
+        provider,
+        instructions: options.instructions || undefined,
+        speed,
+    });
+    if (result instanceof Error) {
+        cliLogger.error(`Speech generation failed: ${result.message}`);
+        process.exit(EXIT_NO_RESTART);
+    }
+    const ext = result.mediaType === 'audio/mp3' ? 'mp3' : 'wav';
+    const outputPath = options.output || `speech.${ext}`;
+    const resolvedOutput = path.resolve(outputPath);
+    await fs.promises.writeFile(resolvedOutput, result.audio);
+    cliLogger.log(`Audio saved to ${resolvedOutput} (${(result.audio.length / 1024).toFixed(1)} KB)`);
+    process.exit(0);
+});
 export default cli;

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

@@ -39,6 +39,8 @@ cli
     .option('--mention-mode', 'Bot only responds when @mentioned (default for all channels)')
     .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>)')
@@ -134,6 +136,8 @@ 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 }),
         });
@@ -143,6 +147,9 @@ cli
         if (disabledSkills.length > 0) {
             cliLogger.log(`Skill blacklist enabled: [${disabledSkills.join(', ')}] will be hidden`);
         }
+        if (options.allowAllUsers) {
+            cliLogger.log('Allow all users: any Discord member can start sessions (no-kimaki role still blocks)');
+        }
         if (options.verbosity) {
             cliLogger.log(`Default verbosity: ${options.verbosity}`);
         }
@@ -152,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,10 +1,13 @@
 // /agent command - Set the preferred agent for this channel or session.
 // Also provides quick agent commands like /plan-agent, /build-agent that switch instantly.
-import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, MessageFlags, } from 'discord.js';
+// When a prompt is provided to a quick agent command (e.g. /plan-agent "fix the bug"),
+// 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';
 import { initializeOpencodeForDirectory } from '../opencode.js';
-import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
+import { resolveTextChannel, resolveWorkingDirectory, getKimakiMetadata, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { getCurrentModelInfo } from './model.js';
 const agentLogger = createLogger(LogPrefix.AGENT);
@@ -159,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;
@@ -286,7 +289,13 @@ export async function handleAgentSelectMenu(interaction) {
  */
 export async function handleQuickAgentCommand({ command, appId, }) {
     const fallbackAgentName = command.commandName.replace(/-agent$/, '');
-    await command.deferReply({ flags: MessageFlags.Ephemeral });
+    const prompt = command.options.getString('prompt') || undefined;
+    // 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();
     const context = await resolveAgentCommandContext({
         interaction: command,
         appId,
@@ -352,3 +361,106 @@ export async function handleQuickAgentCommand({ command, appId, }) {
         });
     }
 }
+/**
+ * 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;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const resolvedAgentName = (await resolveQuickAgentNameFromInteraction({ command })) ||
+        fallbackAgentName;
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    const displayText = `${prompt.slice(0, 1000)}${prompt.length > 1000 ? '...' : ''}`;
+    if (isThread) {
+        // 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) {
+            await command.reply({
+                content: 'Could not determine project directory for this channel',
+                flags: MessageFlags.Ephemeral,
+            });
+            return;
+        }
+        const runtime = getOrCreateRuntime({
+            threadId: thread.id,
+            thread,
+            projectDirectory: resolved.projectDirectory,
+            sdkDirectory: resolved.workingDirectory,
+            channelId: thread.parentId || thread.id,
+            appId,
+        });
+        // Visible reply showing the one-shot prompt (not ephemeral, so it appears in thread).
+        await command.reply({
+            content: `» **${command.user.displayName}** (${resolvedAgentName}): ${displayText}`,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        await runtime.enqueueIncoming({
+            prompt,
+            userId: command.user.id,
+            username: command.user.displayName,
+            agent: resolvedAgentName,
+            appId,
+            mode: 'opencode',
+        });
+    }
+    else if (channel.type === ChannelType.GuildText) {
+        // 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({
+                content: 'This channel is not configured with a project directory',
+                flags: MessageFlags.Ephemeral,
+            });
+            return;
+        }
+        await command.deferReply();
+        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: `${resolvedAgentName} agent prompt`,
+        });
+        await thread.members.add(command.user.id);
+        await command.editReply(`Sent with **${resolvedAgentName}** agent in ${thread.toString()}`);
+        const runtime = getOrCreateRuntime({
+            threadId: thread.id,
+            thread,
+            projectDirectory,
+            sdkDirectory: projectDirectory,
+            channelId: channel.id,
+            appId,
+        });
+        await runtime.enqueueIncoming({
+            prompt,
+            userId: command.user.id,
+            username: command.user.displayName,
+            agent: resolvedAgentName,
+            appId,
+            mode: 'opencode',
+        });
+    }
+    else {
+        await command.reply({
+            content: 'This command can only be used in text channels or threads',
+            flags: MessageFlags.Ephemeral,
+        });
+    }
+}

package/dist/commands/gemini-apikey.js

@@ -1,11 +1,13 @@
-// Transcription API key button, slash command, and modal handlers.
+// Audio API key button, slash command, and modal handlers.
+// Used for both transcription and speech generation — same OpenAI/Gemini keys.
 // Auto-detects provider from key prefix: sk-* = OpenAI, otherwise Gemini.
-import { ActionRowBuilder, ModalBuilder, TextInputBuilder, TextInputStyle, MessageFlags, } from 'discord.js';
+import { ActionRowBuilder, ButtonBuilder, ButtonStyle, ModalBuilder, TextInputBuilder, TextInputStyle, MessageFlags, } from 'discord.js';
 import { setGeminiApiKey, setOpenAIApiKey } from '../database.js';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 function buildTranscriptionApiKeyModal(appId) {
     const modal = new ModalBuilder()
         .setCustomId(`transcription_apikey_modal:${appId}`)
-        .setTitle('Transcription API Key');
+        .setTitle('Audio API Key');
     const apiKeyInput = new TextInputBuilder()
         .setCustomId('apikey')
         .setLabel('OpenAI or Gemini API Key')
@@ -16,6 +18,23 @@ function buildTranscriptionApiKeyModal(appId) {
     modal.addComponents(actionRow);
     return modal;
 }
+/**
+ * Show a "Set API Key" button in a Discord thread.
+ * Reusable for both transcription and TTS — both use the same stored keys.
+ * The button opens a modal where the user can enter an OpenAI or Gemini key.
+ */
+export async function showApiKeyRequiredButton({ thread, appId, message, }) {
+    const button = new ButtonBuilder()
+        .setCustomId(`transcription_apikey:${appId}`)
+        .setLabel('Set API Key')
+        .setStyle(ButtonStyle.Primary);
+    const row = new ActionRowBuilder().addComponents(button);
+    await thread.send({
+        content: message || 'An API key (OpenAI or Gemini) is required. Set one to continue.',
+        components: [row],
+        flags: SILENT_MESSAGE_FLAGS,
+    });
+}
 export async function handleTranscriptionApiKeyButton(interaction) {
     if (!interaction.customId.startsWith('transcription_apikey:'))
         return;
@@ -58,13 +77,13 @@ export async function handleTranscriptionApiKeyModalSubmit(interaction) {
     if (apiKey.startsWith('sk-')) {
         await setOpenAIApiKey(appId, apiKey);
         await interaction.editReply({
-            content: 'OpenAI API key saved. Voice messages will be transcribed with OpenAI.',
+            content: 'OpenAI API key saved. Voice transcription and speech generation are now enabled.',
         });
     }
     else {
         await setGeminiApiKey(appId, apiKey);
         await interaction.editReply({
-            content: 'Gemini API key saved. Voice messages will be transcribed with Gemini.',
+            content: 'Gemini API key saved. Voice transcription and speech generation are now enabled.',
         });
     }
 }

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) {