kimaki 0.4.50 → 0.4.52

package/dist/channel-management.js

@@ -40,34 +40,38 @@ export async function ensureKimakiAudioCategory(guild, botName) {
         type: ChannelType.GuildCategory,
     });
 }
-export async function createProjectChannels({ guild, projectDirectory, appId, botName, }) {
+export async function createProjectChannels({ guild, projectDirectory, appId, botName, enableVoiceChannels = false, }) {
     const baseName = path.basename(projectDirectory);
     const channelName = `${baseName}`
         .toLowerCase()
         .replace(/[^a-z0-9-]/g, '-')
         .slice(0, 100);
     const kimakiCategory = await ensureKimakiCategory(guild, botName);
-    const kimakiAudioCategory = await ensureKimakiAudioCategory(guild, botName);
     const textChannel = await guild.channels.create({
         name: channelName,
         type: ChannelType.GuildText,
         parent: kimakiCategory,
         // Channel configuration is stored in SQLite, not in the topic
     });
-    const voiceChannel = await guild.channels.create({
-        name: channelName,
-        type: ChannelType.GuildVoice,
-        parent: kimakiAudioCategory,
-    });
     getDatabase()
         .prepare('INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type, app_id) VALUES (?, ?, ?, ?)')
         .run(textChannel.id, projectDirectory, 'text', appId);
-    getDatabase()
-        .prepare('INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type, app_id) VALUES (?, ?, ?, ?)')
-        .run(voiceChannel.id, projectDirectory, 'voice', appId);
+    let voiceChannelId = null;
+    if (enableVoiceChannels) {
+        const kimakiAudioCategory = await ensureKimakiAudioCategory(guild, botName);
+        const voiceChannel = await guild.channels.create({
+            name: channelName,
+            type: ChannelType.GuildVoice,
+            parent: kimakiAudioCategory,
+        });
+        getDatabase()
+            .prepare('INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type, app_id) VALUES (?, ?, ?, ?)')
+            .run(voiceChannel.id, projectDirectory, 'voice', appId);
+        voiceChannelId = voiceChannel.id;
+    }
     return {
         textChannelId: textChannel.id,
-        voiceChannelId: voiceChannel.id,
+        voiceChannelId,
         channelName,
     };
 }

package/dist/cli.js

@@ -213,11 +213,11 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
             .toJSON(),
         new SlashCommandBuilder()
             .setName('add-project')
-            .setDescription('Create Discord channels for a new OpenCode project')
+            .setDescription('Create Discord channels for a project. Use `npx kimaki add-project` for unlisted projects')
             .addStringOption((option) => {
             option
                 .setName('project')
-                .setDescription('Select an OpenCode project')
+                .setDescription('Select a project. Use `npx kimaki add-project` if not listed')
                 .setRequired(true)
                 .setAutocomplete(true);
             return option;
@@ -428,7 +428,7 @@ async function backgroundInit({ currentDir, token, appId, }) {
         cliLogger.error('Background init failed:', error instanceof Error ? error.message : String(error));
     }
 }
-async function run({ restart, addChannels, useWorktrees }) {
+async function run({ restart, addChannels, useWorktrees, enableVoiceChannels }) {
     startCaffeinate();
     const forceSetup = Boolean(restart);
     intro('🤖 Discord Bot Setup');
@@ -777,6 +777,7 @@ async function run({ restart, addChannels, useWorktrees }) {
                         projectDirectory: project.worktree,
                         appId,
                         botName: discordClient.user?.username,
+                        enableVoiceChannels,
                     });
                     createdChannels.push({
                         name: channelName,
@@ -823,6 +824,7 @@ cli
     .option('--data-dir <path>', 'Data directory for config and database (default: ~/.kimaki)')
     .option('--install-url', 'Print the bot install URL and exit')
     .option('--use-worktrees', 'Create git worktrees for all new sessions started from channel messages')
+    .option('--enable-voice-channels', 'Create voice channels for projects (disabled by default)')
     .option('--verbosity <level>', 'Default verbosity for all channels (tools-and-text, text-and-essential-tools, or text-only)')
     .action(async (options) => {
     try {
@@ -859,6 +861,7 @@ cli
             addChannels: options.addChannels,
             dataDir: options.dataDir,
             useWorktrees: options.useWorktrees,
+            enableVoiceChannels: options.enableVoiceChannels,
         });
     }
     catch (error) {
@@ -1217,7 +1220,7 @@ cli
     }
 });
 cli
-    .command('add-project [directory]', 'Create Discord channels for a project directory')
+    .command('add-project [directory]', 'Create Discord channels for a project directory (e.g. ./folder)')
     .option('-g, --guild <guildId>', 'Discord guild/server ID (auto-detects if bot is in only one server)')
     .option('-a, --app-id <appId>', 'Bot application ID (reads from database if available)')
     .action(async (directory, options) => {

package/dist/commands/add-project.js

@@ -52,7 +52,8 @@ export async function handleAddProjectCommand({ command, appId }) {
             appId,
             botName: command.client.user?.username,
         });
-        await command.editReply(`✅ Created channels for project:\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n📁 Directory: \`${directory}\``);
+        const voiceInfo = voiceChannelId ? `\n🔊 Voice: <#${voiceChannelId}>` : '';
+        await command.editReply(`✅ Created channels for project:\n📝 Text: <#${textChannelId}>${voiceInfo}\n📁 Directory: \`${directory}\``);
         logger.log(`Created channels for project ${channelName} at ${directory}`);
     }
     catch (error) {

package/dist/commands/create-new-project.js

@@ -83,7 +83,8 @@ export async function handleCreateNewProjectCommand({ command, appId, }) {
         }
         const { textChannelId, voiceChannelId, channelName, projectDirectory, sanitizedName } = result;
         const textChannel = (await guild.channels.fetch(textChannelId));
-        await command.editReply(`✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n_Starting session..._`);
+        const voiceInfo = voiceChannelId ? `\n🔊 Voice: <#${voiceChannelId}>` : '';
+        await command.editReply(`✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>${voiceInfo}\n_Starting session..._`);
         const starterMessage = await textChannel.send({
             content: `🚀 **New project initialized**\n📁 \`${projectDirectory}\``,
             flags: SILENT_MESSAGE_FLAGS,

package/dist/discord-bot.js

@@ -31,7 +31,7 @@ setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0, connections:
 const discordLogger = createLogger(LogPrefix.DISCORD);
 const voiceLogger = createLogger(LogPrefix.VOICE);
 function prefixWithDiscordUser({ username, prompt }) {
-    return `<discord-user name="${username}" />\n${prompt}`;
+    return `${prompt}\n<discord-user name="${username}" />`;
 }
 export async function createDiscordClient() {
     return new Client({
@@ -117,6 +117,17 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 }
             }
             if (message.guild && message.member) {
+                // Check for "no-kimaki" role first - blocks user regardless of other permissions.
+                // This implements the "four-eyes principle": even owners must remove this role
+                // to use the bot, adding friction to prevent accidental usage.
+                const hasNoKimakiRole = message.member.roles.cache.some((role) => role.name.toLowerCase() === 'no-kimaki');
+                if (hasNoKimakiRole) {
+                    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;
+                }
                 const isOwner = message.member.id === message.guild.ownerId;
                 const isAdmin = message.member.permissions.has(PermissionsBitField.Flags.Administrator);
                 const canManageServer = message.member.permissions.has(PermissionsBitField.Flags.ManageGuild);

package/dist/message-formatting.js

@@ -171,6 +171,7 @@ export async function getFileAttachments(message) {
             mime,
             filename: attachment.name,
             url: dataUrl,
+            sourceUrl: attachment.url,
         };
     }));
     return results.filter((r) => r !== null);

package/dist/session-handler.js

@@ -2,6 +2,9 @@
 // Creates, maintains, and sends prompts to OpenCode sessions from Discord threads.
 // Handles streaming events, permissions, abort signals, and message queuing.
 import prettyMilliseconds from 'pretty-ms';
+import fs from 'node:fs';
+import path from 'node:path';
+import { xdgState } from 'xdg-basedir';
 import { getDatabase, getSessionModel, getChannelModel, getSessionAgent, getChannelAgent, setSessionAgent, getThreadWorktree, getChannelVerbosity, } from './database.js';
 import { initializeOpencodeForDirectory, getOpencodeServers, getOpencodeClientV2, } from './opencode.js';
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from './discord-utils.js';
@@ -57,6 +60,114 @@ export function getQueueLength(threadId) {
 export function clearQueue(threadId) {
     messageQueue.delete(threadId);
 }
+/**
+ * Read user's recent models from OpenCode TUI's state file.
+ * Uses same path as OpenCode: path.join(xdgState, "opencode", "model.json")
+ * Returns all recent models so we can iterate until finding a valid one.
+ * See: opensrc/repos/github.com/sst/opencode/packages/opencode/src/global/index.ts
+ */
+function getRecentModelsFromTuiState() {
+    if (!xdgState) {
+        return [];
+    }
+    // Same path as OpenCode TUI: path.join(Global.Path.state, "model.json")
+    const modelJsonPath = path.join(xdgState, 'opencode', 'model.json');
+    const result = errore.tryFn(() => {
+        const content = fs.readFileSync(modelJsonPath, 'utf-8');
+        const data = JSON.parse(content);
+        return data.recent ?? [];
+    });
+    if (result instanceof Error) {
+        // File doesn't exist or is invalid - this is normal for fresh installs
+        return [];
+    }
+    return result;
+}
+/**
+ * Parse a model string in format "provider/model" into providerID and modelID.
+ */
+function parseModelString(model) {
+    const [providerID, ...modelParts] = model.split('/');
+    const modelID = modelParts.join('/');
+    if (!providerID || !modelID) {
+        return undefined;
+    }
+    return { providerID, modelID };
+}
+/**
+ * Validate that a model is available (provider connected + model exists).
+ */
+function isModelValid(model, connected, providers) {
+    const isConnected = connected.includes(model.providerID);
+    const provider = providers.find((p) => p.id === model.providerID);
+    const modelExists = provider?.models && model.modelID in provider.models;
+    return isConnected && !!modelExists;
+}
+/**
+ * Get the default model from OpenCode when no user preference is set.
+ * Priority (matches OpenCode TUI behavior):
+ * 1. OpenCode config.model setting
+ * 2. User's recent models from TUI state (~/.local/state/opencode/model.json)
+ * 3. First connected provider's default model from API
+ */
+async function getDefaultModel({ getClient, directory, }) {
+    if (getClient instanceof Error) {
+        return undefined;
+    }
+    // Fetch connected providers to validate any model we return
+    const providersResponse = await errore.tryAsync(() => {
+        return getClient().provider.list({ query: { directory } });
+    });
+    if (providersResponse instanceof Error) {
+        sessionLogger.log(`[MODEL] Failed to fetch providers for default model:`, providersResponse.message);
+        return undefined;
+    }
+    if (!providersResponse.data) {
+        return undefined;
+    }
+    const { connected, default: defaults, all: providers } = providersResponse.data;
+    if (connected.length === 0) {
+        sessionLogger.log(`[MODEL] No connected providers found`);
+        return undefined;
+    }
+    // 1. Check OpenCode config.model setting (highest priority after user preference)
+    const configResponse = await errore.tryAsync(() => {
+        return getClient().config.get({ query: { directory } });
+    });
+    if (!(configResponse instanceof Error) && configResponse.data?.model) {
+        const configModel = parseModelString(configResponse.data.model);
+        if (configModel && isModelValid(configModel, connected, providers)) {
+            sessionLogger.log(`[MODEL] Using config model: ${configModel.providerID}/${configModel.modelID}`);
+            return configModel;
+        }
+        if (configModel) {
+            sessionLogger.log(`[MODEL] Config model ${configResponse.data.model} not available, checking recent`);
+        }
+    }
+    // 2. Try to use user's recent models from TUI state (iterate until finding valid one)
+    const recentModels = getRecentModelsFromTuiState();
+    for (const recentModel of recentModels) {
+        if (isModelValid(recentModel, connected, providers)) {
+            sessionLogger.log(`[MODEL] Using recent TUI model: ${recentModel.providerID}/${recentModel.modelID}`);
+            return recentModel;
+        }
+    }
+    if (recentModels.length > 0) {
+        sessionLogger.log(`[MODEL] No valid recent TUI models found`);
+    }
+    // 3. Fall back to first connected provider's default model
+    const firstConnected = connected[0];
+    if (!firstConnected) {
+        return undefined;
+    }
+    const defaultModelId = defaults[firstConnected];
+    if (!defaultModelId) {
+        sessionLogger.log(`[MODEL] No default model for provider ${firstConnected}`);
+        return undefined;
+    }
+    sessionLogger.log(`[MODEL] Using provider default: ${firstConnected}/${defaultModelId}`);
+    return { providerID: firstConnected, modelID: defaultModelId };
+}
 /**
  * Abort a running session and retry with the last user message.
  * Used when model preference changes mid-request.
@@ -774,7 +885,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             sessionLogger.log(`[QUEUE] Question shown but queue has messages, processing from ${nextMessage.username}`);
             await sendThreadMessage(thread, `» **${nextMessage.username}:** ${nextMessage.prompt.slice(0, 150)}${nextMessage.prompt.length > 150 ? '...' : ''}`);
             setImmediate(() => {
-                const prefixedPrompt = `<discord-user name="${nextMessage.username}" />\n${nextMessage.prompt}`;
+                const prefixedPrompt = `${nextMessage.prompt}\n<discord-user name="${nextMessage.username}" />`;
                 void errore
                     .tryAsync(async () => {
                     return handleOpencodeSession({
@@ -950,7 +1061,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                     // Send the queued message as a new prompt (recursive call)
                     // Use setImmediate to avoid blocking and allow this finally to complete
                     setImmediate(() => {
-                        const prefixedPrompt = `<discord-user name="${nextMessage.username}" />\n${nextMessage.prompt}`;
+                        const prefixedPrompt = `${nextMessage.prompt}\n<discord-user name="${nextMessage.username}" />`;
                         handleOpencodeSession({
                             prompt: prefixedPrompt,
                             thread,
@@ -991,11 +1102,13 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             sessionLogger.log(`[PROMPT] Sending ${images.length} image(s):`, images.map((img) => ({
                 mime: img.mime,
                 filename: img.filename,
-                urlPreview: img.url.slice(0, 50) + '...',
+                sourceUrl: img.sourceUrl,
             })));
-            // Just list filenames, not the full base64 URLs (images are passed as separate parts)
-            const imageList = images.map((img) => `- ${img.filename}`).join('\n');
-            return `${prompt}\n\n**attached images:**\n${imageList}`;
+            // List source URLs and clarify these images are already in context (not paths to read)
+            const imageList = images
+                .map((img) => `- ${img.sourceUrl || img.filename}`)
+                .join('\n');
+            return `${prompt}\n\n**The following images are already included in this message as inline content (do not use Read tool on these):**\n${imageList}`;
         })();
         const parts = [{ type: 'text', text: promptWithImagePaths }, ...images];
         sessionLogger.log(`[PROMPT] Parts to send:`, parts.length);
@@ -1004,22 +1117,44 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
             sessionLogger.log(`[AGENT] Using agent preference: ${agentPreference}`);
         }
         const modelPreference = getSessionModel(session.id) || (channelId ? getChannelModel(channelId) : undefined);
-        const modelParam = (() => {
-            if (agentPreference) {
-                sessionLogger.log(`[MODEL] Skipping model param, agent "${agentPreference}" controls model`);
-                return undefined;
+        const modelParam = await (async () => {
+            // Use explicit user preference if set (takes priority over agent model)
+            if (modelPreference) {
+                const [providerID, ...modelParts] = modelPreference.split('/');
+                const modelID = modelParts.join('/');
+                if (providerID && modelID) {
+                    sessionLogger.log(`[MODEL] Using preference: ${modelPreference}`);
+                    return { providerID, modelID };
+                }
             }
-            if (!modelPreference) {
-                return undefined;
+            // If agent is set, check if agent has a model configured
+            if (agentPreference) {
+                const agentsResponse = await errore.tryAsync(() => {
+                    return getClient().app.agents({ query: { directory: sdkDirectory } });
+                });
+                if (!(agentsResponse instanceof Error) && agentsResponse.data) {
+                    const agent = agentsResponse.data.find((a) => a.name === agentPreference);
+                    if (agent?.model) {
+                        sessionLogger.log(`[MODEL] Using agent model: ${agent.model.providerID}/${agent.model.modelID}`);
+                        return agent.model;
+                    }
+                    sessionLogger.log(`[MODEL] Agent "${agentPreference}" has no model configured, using default`);
+                }
             }
-            const [providerID, ...modelParts] = modelPreference.split('/');
-            const modelID = modelParts.join('/');
-            if (!providerID || !modelID) {
-                return undefined;
+            // Fetch default model from OpenCode (like TUI does)
+            const defaultModel = await getDefaultModel({ getClient, directory: sdkDirectory });
+            if (defaultModel) {
+                sessionLogger.log(`[MODEL] Using default: ${defaultModel.providerID}/${defaultModel.modelID}`);
+                return defaultModel;
             }
-            sessionLogger.log(`[MODEL] Using model preference: ${modelPreference}`);
-            return { providerID, modelID };
+            // No model available - this will likely cause an error from OpenCode
+            sessionLogger.log(`[MODEL] No model available (no preference, no default)`);
+            return undefined;
         })();
+        // Fail early if no model available
+        if (!modelParam) {
+            throw new Error('No AI provider connected. Configure a provider in OpenCode with `/connect` command.');
+        }
         // Build worktree info for system message (worktreeInfo was fetched at the start)
         const worktree = worktreeInfo?.status === 'ready' && worktreeInfo.worktree_directory
             ? {

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.50",
+  "version": "0.4.52",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -41,6 +41,7 @@
     "ripgrep-js": "^3.0.0",
     "string-dedent": "^3.0.2",
     "undici": "^7.16.0",
+    "xdg-basedir": "^5.1.0",
     "zod": "^4.2.1",
     "errore": "^0.10.0"
   },

package/src/channel-management.ts

@@ -63,12 +63,14 @@ export async function createProjectChannels({
   projectDirectory,
   appId,
   botName,
+  enableVoiceChannels = false,
 }: {
   guild: Guild
   projectDirectory: string
   appId: string
   botName?: string
-}): Promise<{ textChannelId: string; voiceChannelId: string; channelName: string }> {
+  enableVoiceChannels?: boolean
+}): Promise<{ textChannelId: string; voiceChannelId: string | null; channelName: string }> {
   const baseName = path.basename(projectDirectory)
   const channelName = `${baseName}`
     .toLowerCase()
@@ -76,7 +78,6 @@ export async function createProjectChannels({
     .slice(0, 100)
 
   const kimakiCategory = await ensureKimakiCategory(guild, botName)
-  const kimakiAudioCategory = await ensureKimakiAudioCategory(guild, botName)
 
   const textChannel = await guild.channels.create({
     name: channelName,
@@ -85,27 +86,35 @@ export async function createProjectChannels({
     // Channel configuration is stored in SQLite, not in the topic
   })
 
-  const voiceChannel = await guild.channels.create({
-    name: channelName,
-    type: ChannelType.GuildVoice,
-    parent: kimakiAudioCategory,
-  })
-
   getDatabase()
     .prepare(
       'INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type, app_id) VALUES (?, ?, ?, ?)',
     )
     .run(textChannel.id, projectDirectory, 'text', appId)
 
-  getDatabase()
-    .prepare(
-      'INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type, app_id) VALUES (?, ?, ?, ?)',
-    )
-    .run(voiceChannel.id, projectDirectory, 'voice', appId)
+  let voiceChannelId: string | null = null
+
+  if (enableVoiceChannels) {
+    const kimakiAudioCategory = await ensureKimakiAudioCategory(guild, botName)
+
+    const voiceChannel = await guild.channels.create({
+      name: channelName,
+      type: ChannelType.GuildVoice,
+      parent: kimakiAudioCategory,
+    })
+
+    getDatabase()
+      .prepare(
+        'INSERT OR REPLACE INTO channel_directories (channel_id, directory, channel_type, app_id) VALUES (?, ?, ?, ?)',
+      )
+      .run(voiceChannel.id, projectDirectory, 'voice', appId)
+
+    voiceChannelId = voiceChannel.id
+  }
 
   return {
     textChannelId: textChannel.id,
-    voiceChannelId: voiceChannel.id,
+    voiceChannelId,
     channelName,
   }
 }

package/src/cli.ts

@@ -209,6 +209,7 @@ type CliOptions = {
   addChannels?: boolean
   dataDir?: string
   useWorktrees?: boolean
+  enableVoiceChannels?: boolean
 }
 
 // Commands to skip when registering user commands (reserved names)
@@ -298,11 +299,11 @@ async function registerCommands({
       .toJSON(),
     new SlashCommandBuilder()
       .setName('add-project')
-      .setDescription('Create Discord channels for a new OpenCode project')
+      .setDescription('Create Discord channels for a project. Use `npx kimaki add-project` for unlisted projects')
       .addStringOption((option) => {
         option
           .setName('project')
-          .setDescription('Select an OpenCode project')
+          .setDescription('Select a project. Use `npx kimaki add-project` if not listed')
           .setRequired(true)
           .setAutocomplete(true)
 
@@ -595,7 +596,7 @@ async function backgroundInit({
   }
 }
 
-async function run({ restart, addChannels, useWorktrees }: CliOptions) {
+async function run({ restart, addChannels, useWorktrees, enableVoiceChannels }: CliOptions) {
   startCaffeinate()
 
   const forceSetup = Boolean(restart)
@@ -1057,6 +1058,7 @@ async function run({ restart, addChannels, useWorktrees }: CliOptions) {
             projectDirectory: project.worktree,
             appId,
             botName: discordClient.user?.username,
+            enableVoiceChannels,
           })
 
           createdChannels.push({
@@ -1123,6 +1125,7 @@ cli
   .option('--data-dir <path>', 'Data directory for config and database (default: ~/.kimaki)')
   .option('--install-url', 'Print the bot install URL and exit')
   .option('--use-worktrees', 'Create git worktrees for all new sessions started from channel messages')
+  .option('--enable-voice-channels', 'Create voice channels for projects (disabled by default)')
   .option('--verbosity <level>', 'Default verbosity for all channels (tools-and-text, text-and-essential-tools, or text-only)')
   .action(
     async (options: {
@@ -1131,6 +1134,7 @@ cli
       dataDir?: string
       installUrl?: boolean
       useWorktrees?: boolean
+      enableVoiceChannels?: boolean
       verbosity?: string
     }) => {
       try {
@@ -1172,6 +1176,7 @@ cli
           addChannels: options.addChannels,
           dataDir: options.dataDir,
           useWorktrees: options.useWorktrees,
+          enableVoiceChannels: options.enableVoiceChannels,
         })
       } catch (error) {
         cliLogger.error('Unhandled error:', error instanceof Error ? error.message : String(error))
@@ -1639,7 +1644,7 @@ cli
   })
 
 cli
-  .command('add-project [directory]', 'Create Discord channels for a project directory')
+  .command('add-project [directory]', 'Create Discord channels for a project directory (e.g. ./folder)')
   .option('-g, --guild <guildId>', 'Discord guild/server ID (auto-detects if bot is in only one server)')
   .option('-a, --app-id <appId>', 'Bot application ID (reads from database if available)')
   .action(

package/src/commands/add-project.ts

@@ -72,8 +72,9 @@ export async function handleAddProjectCommand({ command, appId }: CommandContext
       botName: command.client.user?.username,
     })
 
+    const voiceInfo = voiceChannelId ? `\n🔊 Voice: <#${voiceChannelId}>` : ''
     await command.editReply(
-      `✅ Created channels for project:\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n📁 Directory: \`${directory}\``,
+      `✅ Created channels for project:\n📝 Text: <#${textChannelId}>${voiceInfo}\n📁 Directory: \`${directory}\``,
     )
 
     logger.log(`Created channels for project ${channelName} at ${directory}`)

package/src/commands/create-new-project.ts

@@ -31,7 +31,7 @@ export async function createNewProject({
   botName?: string
 }): Promise<{
   textChannelId: string
-  voiceChannelId: string
+  voiceChannelId: string | null
   channelName: string
   projectDirectory: string
   sanitizedName: string
@@ -124,8 +124,9 @@ export async function handleCreateNewProjectCommand({
     const { textChannelId, voiceChannelId, channelName, projectDirectory, sanitizedName } = result
     const textChannel = (await guild.channels.fetch(textChannelId)) as TextChannel
 
+    const voiceInfo = voiceChannelId ? `\n🔊 Voice: <#${voiceChannelId}>` : ''
     await command.editReply(
-      `✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>\n🔊 Voice: <#${voiceChannelId}>\n_Starting session..._`,
+      `✅ Created new project **${sanitizedName}**\n📁 Directory: \`${projectDirectory}\`\n📝 Text: <#${textChannelId}>${voiceInfo}\n_Starting session..._`,
     )
 
     const starterMessage = await textChannel.send({

package/src/discord-bot.ts

@@ -78,7 +78,7 @@ const discordLogger = createLogger(LogPrefix.DISCORD)
 const voiceLogger = createLogger(LogPrefix.VOICE)
 
 function prefixWithDiscordUser({ username, prompt }: { username: string; prompt: string }): string {
-  return `<discord-user name="${username}" />\n${prompt}`
+  return `${prompt}\n<discord-user name="${username}" />`
 }
 
 type StartOptions = {
@@ -193,6 +193,20 @@ export async function startDiscordBot({
       }
 
       if (message.guild && message.member) {
+        // Check for "no-kimaki" role first - blocks user regardless of other permissions.
+        // This implements the "four-eyes principle": even owners must remove this role
+        // to use the bot, adding friction to prevent accidental usage.
+        const hasNoKimakiRole = message.member.roles.cache.some(
+          (role) => role.name.toLowerCase() === 'no-kimaki',
+        )
+        if (hasNoKimakiRole) {
+          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
+        }
+
         const isOwner = message.member.id === message.guild.ownerId
         const isAdmin = message.member.permissions.has(PermissionsBitField.Flags.Administrator)
         const canManageServer = message.member.permissions.has(

package/src/message-formatting.ts

@@ -5,6 +5,11 @@
 import type { Part } from '@opencode-ai/sdk/v2'
 import type { FilePartInput } from '@opencode-ai/sdk'
 import type { Message } from 'discord.js'
+
+// Extended FilePartInput with original Discord URL for reference in prompts
+export type DiscordFileAttachment = FilePartInput & {
+  sourceUrl?: string
+}
 import * as errore from 'errore'
 import { createLogger, LogPrefix } from './logger.js'
 import { FetchError } from './errors.js'
@@ -179,7 +184,7 @@ export async function getTextAttachments(message: Message): Promise<string> {
   return textContents.join('\n\n')
 }
 
-export async function getFileAttachments(message: Message): Promise<FilePartInput[]> {
+export async function getFileAttachments(message: Message): Promise<DiscordFileAttachment[]> {
   const fileAttachments = Array.from(message.attachments.values()).filter((attachment) => {
     const contentType = attachment.contentType || ''
     return contentType.startsWith('image/') || contentType === 'application/pdf'
@@ -220,11 +225,12 @@ export async function getFileAttachments(message: Message): Promise<FilePartInpu
         mime,
         filename: attachment.name,
         url: dataUrl,
+        sourceUrl: attachment.url,
       }
     }),
   )
 
-  return results.filter((r) => r !== null) as FilePartInput[]
+  return results.filter((r) => r !== null) as DiscordFileAttachment[]
 }
 
 export function getToolSummaryText(part: Part): string {

package/src/session-handler.ts

@@ -3,9 +3,12 @@
 // Handles streaming events, permissions, abort signals, and message queuing.
 
 import type { Part, PermissionRequest, QuestionRequest } from '@opencode-ai/sdk/v2'
-import type { FilePartInput } from '@opencode-ai/sdk'
+import type { DiscordFileAttachment } from './message-formatting.js'
 import type { Message, ThreadChannel } from 'discord.js'
 import prettyMilliseconds from 'pretty-ms'
+import fs from 'node:fs'
+import path from 'node:path'
+import { xdgState } from 'xdg-basedir'
 import {
   getDatabase,
   getSessionModel,
@@ -96,7 +99,7 @@ export type QueuedMessage = {
   userId: string
   username: string
   queuedAt: number
-  images?: FilePartInput[]
+  images?: DiscordFileAttachment[]
 }
 
 // Queue of messages waiting to be sent after current response finishes
@@ -126,6 +129,143 @@ export function clearQueue(threadId: string): void {
   messageQueue.delete(threadId)
 }
 
+/**
+ * Read user's recent models from OpenCode TUI's state file.
+ * Uses same path as OpenCode: path.join(xdgState, "opencode", "model.json")
+ * Returns all recent models so we can iterate until finding a valid one.
+ * See: opensrc/repos/github.com/sst/opencode/packages/opencode/src/global/index.ts
+ */
+function getRecentModelsFromTuiState(): Array<{ providerID: string; modelID: string }> {
+  if (!xdgState) {
+    return []
+  }
+  // Same path as OpenCode TUI: path.join(Global.Path.state, "model.json")
+  const modelJsonPath = path.join(xdgState, 'opencode', 'model.json')
+
+  const result = errore.tryFn(() => {
+    const content = fs.readFileSync(modelJsonPath, 'utf-8')
+    const data = JSON.parse(content) as {
+      recent?: Array<{ providerID: string; modelID: string }>
+    }
+    return data.recent ?? []
+  })
+
+  if (result instanceof Error) {
+    // File doesn't exist or is invalid - this is normal for fresh installs
+    return []
+  }
+
+  return result
+}
+
+/**
+ * Parse a model string in format "provider/model" into providerID and modelID.
+ */
+function parseModelString(model: string): { providerID: string; modelID: string } | undefined {
+  const [providerID, ...modelParts] = model.split('/')
+  const modelID = modelParts.join('/')
+  if (!providerID || !modelID) {
+    return undefined
+  }
+  return { providerID, modelID }
+}
+
+/**
+ * Validate that a model is available (provider connected + model exists).
+ */
+function isModelValid(
+  model: { providerID: string; modelID: string },
+  connected: string[],
+  providers: Array<{ id: string; models?: Record<string, unknown> }>,
+): boolean {
+  const isConnected = connected.includes(model.providerID)
+  const provider = providers.find((p) => p.id === model.providerID)
+  const modelExists = provider?.models && model.modelID in provider.models
+  return isConnected && !!modelExists
+}
+
+/**
+ * Get the default model from OpenCode when no user preference is set.
+ * Priority (matches OpenCode TUI behavior):
+ * 1. OpenCode config.model setting
+ * 2. User's recent models from TUI state (~/.local/state/opencode/model.json)
+ * 3. First connected provider's default model from API
+ */
+async function getDefaultModel({
+  getClient,
+  directory,
+}: {
+  getClient: Awaited<ReturnType<typeof initializeOpencodeForDirectory>>
+  directory: string
+}): Promise<{ providerID: string; modelID: string } | undefined> {
+  if (getClient instanceof Error) {
+    return undefined
+  }
+
+  // Fetch connected providers to validate any model we return
+  const providersResponse = await errore.tryAsync(() => {
+    return getClient().provider.list({ query: { directory } })
+  })
+  if (providersResponse instanceof Error) {
+    sessionLogger.log(`[MODEL] Failed to fetch providers for default model:`, providersResponse.message)
+    return undefined
+  }
+  if (!providersResponse.data) {
+    return undefined
+  }
+
+  const { connected, default: defaults, all: providers } = providersResponse.data
+  if (connected.length === 0) {
+    sessionLogger.log(`[MODEL] No connected providers found`)
+    return undefined
+  }
+
+  // 1. Check OpenCode config.model setting (highest priority after user preference)
+  const configResponse = await errore.tryAsync(() => {
+    return getClient().config.get({ query: { directory } })
+  })
+  if (!(configResponse instanceof Error) && configResponse.data?.model) {
+    const configModel = parseModelString(configResponse.data.model)
+    if (configModel && isModelValid(configModel, connected, providers)) {
+      sessionLogger.log(`[MODEL] Using config model: ${configModel.providerID}/${configModel.modelID}`)
+      return configModel
+    }
+    if (configModel) {
+      sessionLogger.log(
+        `[MODEL] Config model ${configResponse.data.model} not available, checking recent`,
+      )
+    }
+  }
+
+  // 2. Try to use user's recent models from TUI state (iterate until finding valid one)
+  const recentModels = getRecentModelsFromTuiState()
+  for (const recentModel of recentModels) {
+    if (isModelValid(recentModel, connected, providers)) {
+      sessionLogger.log(
+        `[MODEL] Using recent TUI model: ${recentModel.providerID}/${recentModel.modelID}`,
+      )
+      return recentModel
+    }
+  }
+  if (recentModels.length > 0) {
+    sessionLogger.log(`[MODEL] No valid recent TUI models found`)
+  }
+
+  // 3. Fall back to first connected provider's default model
+  const firstConnected = connected[0]
+  if (!firstConnected) {
+    return undefined
+  }
+  const defaultModelId = defaults[firstConnected]
+  if (!defaultModelId) {
+    sessionLogger.log(`[MODEL] No default model for provider ${firstConnected}`)
+    return undefined
+  }
+
+  sessionLogger.log(`[MODEL] Using provider default: ${firstConnected}/${defaultModelId}`)
+  return { providerID: firstConnected, modelID: defaultModelId }
+}
+
 /**
  * Abort a running session and retry with the last user message.
  * Used when model preference changes mid-request.
@@ -189,7 +329,7 @@ export async function abortAndRetrySession({
     | { type: 'text'; text: string }
     | undefined
   const prompt = textPart?.text || ''
-  const images = lastUserMessage.parts.filter((p) => p.type === 'file') as FilePartInput[]
+  const images = lastUserMessage.parts.filter((p) => p.type === 'file') as DiscordFileAttachment[]
 
   sessionLogger.log(`[ABORT+RETRY] Re-triggering session ${sessionId} with new model`)
 
@@ -233,7 +373,7 @@ export async function handleOpencodeSession({
   thread: ThreadChannel
   projectDirectory?: string
   originalMessage?: Message
-  images?: FilePartInput[]
+  images?: DiscordFileAttachment[]
   channelId?: string
   /** If set, uses session.command API instead of session.prompt */
   command?: { name: string; arguments: string }
@@ -1059,7 +1199,7 @@ export async function handleOpencodeSession({
       )
 
       setImmediate(() => {
-        const prefixedPrompt = `<discord-user name="${nextMessage.username}" />\n${nextMessage.prompt}`
+        const prefixedPrompt = `${nextMessage.prompt}\n<discord-user name="${nextMessage.username}" />`
         void errore
           .tryAsync(async () => {
             return handleOpencodeSession({
@@ -1272,7 +1412,7 @@ export async function handleOpencodeSession({
           // Send the queued message as a new prompt (recursive call)
           // Use setImmediate to avoid blocking and allow this finally to complete
           setImmediate(() => {
-            const prefixedPrompt = `<discord-user name="${nextMessage.username}" />\n${nextMessage.prompt}`
+            const prefixedPrompt = `${nextMessage.prompt}\n<discord-user name="${nextMessage.username}" />`
             handleOpencodeSession({
               prompt: prefixedPrompt,
               thread,
@@ -1323,12 +1463,14 @@ export async function handleOpencodeSession({
         images.map((img) => ({
           mime: img.mime,
           filename: img.filename,
-          urlPreview: img.url.slice(0, 50) + '...',
+          sourceUrl: img.sourceUrl,
         })),
       )
-      // Just list filenames, not the full base64 URLs (images are passed as separate parts)
-      const imageList = images.map((img) => `- ${img.filename}`).join('\n')
-      return `${prompt}\n\n**attached images:**\n${imageList}`
+      // List source URLs and clarify these images are already in context (not paths to read)
+      const imageList = images
+        .map((img) => `- ${img.sourceUrl || img.filename}`)
+        .join('\n')
+      return `${prompt}\n\n**The following images are already included in this message as inline content (do not use Read tool on these):**\n${imageList}`
     })()
 
     const parts = [{ type: 'text' as const, text: promptWithImagePaths }, ...images]
@@ -1342,23 +1484,53 @@ export async function handleOpencodeSession({
 
     const modelPreference =
       getSessionModel(session.id) || (channelId ? getChannelModel(channelId) : undefined)
-    const modelParam = (() => {
-      if (agentPreference) {
-        sessionLogger.log(`[MODEL] Skipping model param, agent "${agentPreference}" controls model`)
-        return undefined
+    const modelParam = await (async () => {
+      // Use explicit user preference if set (takes priority over agent model)
+      if (modelPreference) {
+        const [providerID, ...modelParts] = modelPreference.split('/')
+        const modelID = modelParts.join('/')
+        if (providerID && modelID) {
+          sessionLogger.log(`[MODEL] Using preference: ${modelPreference}`)
+          return { providerID, modelID }
+        }
       }
-      if (!modelPreference) {
-        return undefined
+
+      // If agent is set, check if agent has a model configured
+      if (agentPreference) {
+        const agentsResponse = await errore.tryAsync(() => {
+          return getClient().app.agents({ query: { directory: sdkDirectory } })
+        })
+        if (!(agentsResponse instanceof Error) && agentsResponse.data) {
+          const agent = agentsResponse.data.find((a) => a.name === agentPreference)
+          if (agent?.model) {
+            sessionLogger.log(
+              `[MODEL] Using agent model: ${agent.model.providerID}/${agent.model.modelID}`,
+            )
+            return agent.model
+          }
+          sessionLogger.log(`[MODEL] Agent "${agentPreference}" has no model configured, using default`)
+        }
       }
-      const [providerID, ...modelParts] = modelPreference.split('/')
-      const modelID = modelParts.join('/')
-      if (!providerID || !modelID) {
-        return undefined
+
+      // Fetch default model from OpenCode (like TUI does)
+      const defaultModel = await getDefaultModel({ getClient, directory: sdkDirectory })
+      if (defaultModel) {
+        sessionLogger.log(`[MODEL] Using default: ${defaultModel.providerID}/${defaultModel.modelID}`)
+        return defaultModel
       }
-      sessionLogger.log(`[MODEL] Using model preference: ${modelPreference}`)
-      return { providerID, modelID }
+
+      // No model available - this will likely cause an error from OpenCode
+      sessionLogger.log(`[MODEL] No model available (no preference, no default)`)
+      return undefined
     })()
 
+    // Fail early if no model available
+    if (!modelParam) {
+      throw new Error(
+        'No AI provider connected. Configure a provider in OpenCode with `/connect` command.',
+      )
+    }
+
     // Build worktree info for system message (worktreeInfo was fetched at the start)
     const worktree: WorktreeInfo | undefined =
       worktreeInfo?.status === 'ready' && worktreeInfo.worktree_directory