kimaki 0.24.0 → 0.26.0

package/dist/cloudflare-transcription.js

@@ -0,0 +1,56 @@
+// Free Whisper transcription fallback via the kimaki.dev Cloudflare Worker.
+// Only usable in gateway mode: the worker authenticates the request against
+// the shared gateway_clients Postgres table using the CLI's own
+// clientId:clientSecret pair (the same credentials already used for
+// gateway-proxy REST/WebSocket calls), then runs
+// @cf/openai/whisper-large-v3-turbo on Cloudflare's own Workers AI account.
+// This means transcription costs Kimaki, never the user, so voice messages
+// work out of the box for gateway-mode installs with no OpenAI/Gemini key
+// configured.
+//
+// See website/src/server.tsx POST /api/transcribe for the server side.
+// Rate limits (per-client burst + daily request cap) are enforced there,
+// not here — a 429 from the worker just means this fallback is unavailable
+// right now and the caller should fall back to the "add API key" dialog.
+import { TranscriptionError } from './errors.js';
+import { createLogger, LogPrefix } from './logger.js';
+const voiceLogger = createLogger(LogPrefix.VOICE);
+const KIMAKI_TRANSCRIBE_URL = process.env.KIMAKI_TRANSCRIBE_URL || 'https://kimaki.dev/api/transcribe';
+export async function transcribeViaKimakiGateway({ audio, mediaType, clientId, clientSecret, }) {
+    const response = await fetch(KIMAKI_TRANSCRIBE_URL, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${clientId}:${clientSecret}`,
+            'Content-Type': mediaType || 'audio/ogg',
+        },
+        body: audio,
+    }).catch((cause) => {
+        return new TranscriptionError({
+            reason: 'Failed to reach kimaki.dev transcription endpoint',
+            cause,
+        });
+    });
+    if (response instanceof TranscriptionError)
+        return response;
+    if (!response.ok) {
+        const bodyText = await response.text().catch(() => '');
+        voiceLogger.log(`Kimaki gateway transcription failed: ${response.status} ${bodyText}`);
+        return new TranscriptionError({
+            reason: `kimaki.dev returned ${response.status}${bodyText ? `: ${bodyText}` : ''}`,
+        });
+    }
+    const data = (await response.json().catch((cause) => {
+        return new TranscriptionError({
+            reason: 'Failed to parse transcription response',
+            cause,
+        });
+    }));
+    if (data instanceof TranscriptionError)
+        return data;
+    if (!data.text) {
+        return new TranscriptionError({
+            reason: 'Empty transcription response from kimaki gateway',
+        });
+    }
+    return data.text;
+}

package/dist/commands/agent.js

@@ -9,7 +9,7 @@ import { initializeOpencodeForDirectory } from '../opencode.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';
+import { formatModelSource, getCurrentModelInfo, } from './model.js';
 import { isGitRepositoryRoot } from '../worktrees.js';
 import { formatAutoWorktreeName, createWorktreeInBackground, worktreeCreatingMessage, } from './new-worktree.js';
 import { WORKTREE_PREFIX } from './merge-worktree.js';
@@ -100,7 +100,7 @@ async function resolveQuickAgentNameFromInteraction({ command, }) {
  * Resolve the context for an agent command (directory, channel, session).
  * Returns null if the command cannot be executed in this context.
  */
-export async function resolveAgentCommandContext({ interaction, }) {
+export async function resolveAgentCommandContext({ interaction, appId, }) {
     const channel = interaction.channel;
     if (!channel) {
         await interaction.editReply({
@@ -113,39 +113,35 @@ export async function resolveAgentCommandContext({ interaction, }) {
         ChannelType.PrivateThread,
         ChannelType.AnnouncementThread,
     ].includes(channel.type);
-    let projectDirectory;
-    let targetChannelId;
-    let sessionId;
-    if (isThread) {
-        const thread = channel;
-        const textChannel = await resolveTextChannel(thread);
-        const metadata = await getKimakiMetadata(textChannel);
-        projectDirectory = metadata.projectDirectory;
-        targetChannelId = textChannel?.id || channel.id;
-        sessionId = await getThreadSession(thread.id);
-    }
-    else if (channel.type === ChannelType.GuildText) {
-        const metadata = await getKimakiMetadata(channel);
-        projectDirectory = metadata.projectDirectory;
-        targetChannelId = channel.id;
-    }
-    else {
+    if (!isThread &&
+        channel.type !== ChannelType.GuildText) {
         await interaction.editReply({
             content: 'This command can only be used in text channels or threads',
         });
         return null;
     }
-    if (!projectDirectory) {
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
         await interaction.editReply({
             content: 'This channel is not configured with a project directory',
         });
         return null;
     }
+    const textChannel = isThread
+        ? await resolveTextChannel(channel)
+        : undefined;
+    const sessionId = isThread
+        ? await getThreadSession(channel.id)
+        : undefined;
     return {
-        dir: projectDirectory,
-        channelId: targetChannelId,
+        dir: resolved.projectDirectory,
+        workingDirectory: resolved.workingDirectory,
+        channelId: textChannel?.id || channel.id,
         sessionId,
         isThread,
+        appId,
     };
 }
 /**
@@ -165,6 +161,42 @@ export async function setAgentForContext({ context, agentName, }) {
         agentLogger.log(`Set agent ${agentName} for channel ${context.channelId}`);
     }
 }
+function formatAgentModelLine(modelInfo) {
+    if (modelInfo.type === 'none')
+        return '';
+    const source = formatModelSource({
+        type: modelInfo.type,
+        agentName: modelInfo.type === 'agent' ? modelInfo.agentName : undefined,
+    });
+    const line = `\nModel: *${modelInfo.model}* (${source})`;
+    if (modelInfo.type !== 'session' && modelInfo.type !== 'channel') {
+        return line;
+    }
+    return `${line}\nThis model comes from a ${modelInfo.type} override. Use /model and press Clear override if you want this agent's model.`;
+}
+function formatAgentPreferenceReply({ agentName, previousAgentName, modelInfo, scope, }) {
+    const sameAgent = previousAgentName === agentName;
+    const verb = sameAgent ? 'Using' : 'Switched to';
+    const previousText = !sameAgent && previousAgentName ? ` (was **${previousAgentName}**)` : '';
+    const modelText = formatAgentModelLine(modelInfo);
+    if (scope === 'session') {
+        return `${verb} **${agentName}** agent for this session${previousText}${modelText}\nThe agent will change on the next message.`;
+    }
+    return `${verb} **${agentName}** agent for this channel${previousText}${modelText}\nAll new sessions will use this agent.`;
+}
+async function resolveAgentModelInfo({ context, agentName, }) {
+    const getClient = await initializeOpencodeForDirectory(context.dir);
+    if (getClient instanceof Error)
+        return { type: 'none' };
+    return getCurrentModelInfo({
+        sessionId: context.sessionId,
+        channelId: context.channelId,
+        appId: context.appId,
+        agentPreference: agentName,
+        getClient,
+        directory: context.workingDirectory,
+    });
+}
 export async function handleAgentCommand({ interaction, appId, }) {
     await interaction.deferReply();
     const context = await resolveAgentCommandContext({ interaction, appId });
@@ -178,7 +210,7 @@ export async function handleAgentCommand({ interaction, appId, }) {
             return;
         }
         const agentsResponse = await getClient().app.agents({
-            directory: context.dir,
+            directory: context.workingDirectory,
         });
         if (!agentsResponse.data || agentsResponse.data.length === 0) {
             await interaction.editReply({ content: 'No agents available' });
@@ -259,19 +291,26 @@ export async function handleAgentSelectMenu(interaction) {
         return;
     }
     try {
+        const previousAgent = await getCurrentAgentInfo({
+            sessionId: context.sessionId,
+            channelId: context.channelId,
+        });
+        const previousAgentName = previousAgent.type !== 'none' ? previousAgent.agent : undefined;
         await setAgentForContext({ context, agentName: selectedAgent });
-        if (context.isThread && context.sessionId) {
-            await interaction.editReply({
-                content: `Agent preference set for this session: **${selectedAgent}**\nThe agent will change on the next message.`,
-                components: [],
-            });
-        }
-        else {
-            await interaction.editReply({
-                content: `Agent preference set for this channel: **${selectedAgent}**\nAll new sessions in this channel will use this agent.`,
-                components: [],
-            });
-        }
+        const modelInfo = await resolveAgentModelInfo({
+            context,
+            agentName: selectedAgent,
+        });
+        const scope = context.isThread && context.sessionId ? 'session' : 'channel';
+        await interaction.editReply({
+            content: formatAgentPreferenceReply({
+                agentName: selectedAgent,
+                previousAgentName,
+                modelInfo,
+                scope,
+            }),
+            components: [],
+        });
         pendingAgentContexts.delete(contextHash);
     }
     catch (error) {
@@ -317,46 +356,20 @@ export async function handleQuickAgentCommand({ command, appId, }) {
             channelId: context.channelId,
         });
         const previousAgentName = previousAgent.type !== 'none' ? previousAgent.agent : undefined;
-        if (previousAgentName === resolvedAgentName) {
-            await command.editReply({
-                content: `Already using **${resolvedAgentName}** agent`,
-            });
-            return;
-        }
-        // Set the agent preference in DB for this context.
         await setAgentForContext({ context, agentName: resolvedAgentName });
-        const previousText = previousAgentName
-            ? ` (was **${previousAgentName}**)`
-            : '';
-        // Resolve the model that will now be used for the new agent so we can
-        // show it in the reply. setAgentForContext already cleared any session
-        // model preference, so getCurrentModelInfo falls through to the agent's
-        // configured model (or channel/global/default).
-        const modelInfo = await (async () => {
-            const getClient = await initializeOpencodeForDirectory(context.dir);
-            if (getClient instanceof Error) {
-                return { type: 'none' };
-            }
-            return getCurrentModelInfo({
-                sessionId: context.sessionId,
-                channelId: context.channelId,
-                appId,
-                agentPreference: resolvedAgentName,
-                getClient,
-                directory: context.dir,
-            });
-        })();
-        const modelText = modelInfo.type === 'none' ? '' : `\nModel: *${modelInfo.model}*`;
-        if (context.isThread && context.sessionId) {
-            await command.editReply({
-                content: `Switched to **${resolvedAgentName}** agent for this session${previousText}${modelText}\nThe agent will change on the next message.`,
-            });
-        }
-        else {
-            await command.editReply({
-                content: `Switched to **${resolvedAgentName}** agent for this channel${previousText}${modelText}\nAll new sessions will use this agent.`,
-            });
-        }
+        const modelInfo = await resolveAgentModelInfo({
+            context,
+            agentName: resolvedAgentName,
+        });
+        const scope = context.isThread && context.sessionId ? 'session' : 'channel';
+        await command.editReply({
+            content: formatAgentPreferenceReply({
+                agentName: resolvedAgentName,
+                previousAgentName,
+                modelInfo,
+                scope,
+            }),
+        });
     }
     catch (error) {
         agentLogger.error('Error in quick agent command:', error);

package/dist/commands/model-variant.js

@@ -6,7 +6,7 @@
 // Cross-menu state: Discord doesn't expose already-selected values on sibling
 // select menus in the same message. We track partial selections in the context
 // Map. Whichever menu fires second sees the first selection stored and applies.
-import { StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, MessageFlags, } from 'discord.js';
+import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, MessageFlags, } from 'discord.js';
 import crypto from 'node:crypto';
 import { setChannelModel, getThreadSession, setGlobalModel, getVariantCascade, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
@@ -39,6 +39,22 @@ function formatSourceLabel(info) {
             return 'none';
     }
 }
+/** /model-variant slash command entrypoint — defers reply then delegates to the shared picker. */
+export async function handleModelVariantCommand({ interaction, appId, }) {
+    await interaction.deferReply();
+    const channel = interaction.channel;
+    if (!channel) {
+        await interaction.editReply({
+            content: 'This command can only be used in a channel',
+        });
+        return;
+    }
+    await showModelVariantPicker({
+        channel,
+        appId,
+        editReply: (options) => interaction.editReply(options),
+    });
+}
 export async function showModelVariantPicker({ channel, appId, editReply, }) {
     const isThread = [
         ChannelType.PublicThread,

package/dist/commands/model.js

@@ -37,6 +37,24 @@ function setModelContext(contextHash, context) {
         pendingModelContexts.delete(contextHash);
     }, MODEL_CONTEXT_TTL_MS).unref();
 }
+export function formatModelSource({ type, agentName, }) {
+    switch (type) {
+        case 'session':
+            return 'session override';
+        case 'agent':
+            return `agent "${agentName}"`;
+        case 'channel':
+            return 'channel override';
+        case 'global':
+            return 'global default';
+        case 'opencode-config':
+        case 'opencode-recent':
+        case 'opencode-provider-default':
+            return 'opencode default';
+        default:
+            return 'none';
+    }
+}
 function parseModelId(modelString) {
     const [providerID, ...modelParts] = modelString.split('/');
     const modelID = modelParts.join('/');

package/dist/commands/multioauth.js

@@ -1,11 +1,12 @@
 /**
  * CLI commands for multi-provider OAuth account management.
  * Mounted via goke .use() in cli.ts under the `multioauth` namespace.
- * Manages Anthropic and OpenAI OAuth account rotation pools.
+ * Manages Anthropic, OpenAI, and xAI OAuth account rotation pools.
  */
 import { goke } from 'goke';
 import { accountLabel as anthropicAccountLabel, accountsFilePath as anthropicAccountsFilePath, authFilePath, getCurrentAnthropicAccount, loadAccountStore as loadAnthropicAccountStore, removeAccount as removeAnthropicAccount, } from '../anthropic-auth-state.js';
 import { accountLabel as openaiAccountLabel, openaiAccountsFilePath, getCurrentOpenAIAccount, loadOpenAIAccountStore, removeOpenAIAccount, saveOpenAIAccountStore, } from '../openai-auth-state.js';
+import { accountLabel as xaiAccountLabel, xaiAccountsFilePath, getCurrentXAIAccount, loadXAIAccountStore, removeXAIAccount, saveXAIAccountStore, } from '../xai-auth-state.js';
 const EXIT_NO_RESTART = 64;
 function resolveAccountIndex(indexOrEmail, accounts) {
     const value = Number(indexOrEmail);
@@ -25,6 +26,7 @@ multioauth
     .action(async () => {
     const anthropicStore = await loadAnthropicAccountStore();
     const openaiStore = await loadOpenAIAccountStore();
+    const xaiStore = await loadXAIAccountStore();
     console.log('Anthropic OAuth accounts:');
     if (anthropicStore.accounts.length === 0) {
         console.log('  (none)');
@@ -46,6 +48,17 @@ multioauth
             console.log(`  ${active} ${index + 1}. ${openaiAccountLabel(account)}`);
         });
     }
+    console.log('');
+    console.log('xAI OAuth accounts:');
+    if (xaiStore.accounts.length === 0) {
+        console.log('  (none)');
+    }
+    else {
+        xaiStore.accounts.forEach((account, index) => {
+            const active = index === xaiStore.activeIndex ? '*' : ' ';
+            console.log(`  ${active} ${index + 1}. ${xaiAccountLabel(account)}`);
+        });
+    }
     process.exit(0);
 });
 // --- Anthropic subcommands ---
@@ -198,6 +211,9 @@ multioauth
                 const json = (await response.json());
                 accessToken = json.access_token;
                 account.access = accessToken;
+                // OpenAI can rotate refresh tokens; store the new one if returned
+                if (json.refresh_token)
+                    account.refresh = json.refresh_token;
                 account.expires = Date.now() + (json.expires_in ?? 3600) * 1000;
             }
             catch {
@@ -253,4 +269,156 @@ multioauth
     await saveOpenAIAccountStore(store);
     process.exit(0);
 });
+// --- xAI subcommands ---
+multioauth
+    .command('multioauth xai list', 'List stored xAI OAuth accounts used for automatic rotation')
+    .action(async () => {
+    const store = await loadXAIAccountStore();
+    console.log(`Store: ${xaiAccountsFilePath()}`);
+    if (store.accounts.length === 0) {
+        console.log('No xAI OAuth accounts configured.');
+        process.exit(0);
+    }
+    store.accounts.forEach((account, index) => {
+        const active = index === store.activeIndex ? '*' : ' ';
+        console.log(`${active} ${index + 1}. ${xaiAccountLabel(account)}`);
+    });
+    process.exit(0);
+});
+multioauth
+    .command('multioauth xai current', 'Show the current xAI OAuth account being used')
+    .action(async () => {
+    const current = await getCurrentXAIAccount();
+    console.log(`Store: ${xaiAccountsFilePath()}`);
+    console.log(`Auth: ${authFilePath()}`);
+    if (!current) {
+        console.log('No active xAI OAuth account configured.');
+        process.exit(0);
+    }
+    const lines = [];
+    lines.push(`Current: ${xaiAccountLabel(current.account || current.auth, current.index)}`);
+    if (current.account?.email) {
+        lines.push(`Email: ${current.account.email}`);
+    }
+    else {
+        lines.push('Email: unavailable');
+    }
+    if (current.account?.accountId) {
+        lines.push(`Account ID: ${current.account.accountId}`);
+    }
+    if (!current.account) {
+        lines.push('Rotation pool entry: not found');
+    }
+    console.log(lines.join('\n'));
+    process.exit(0);
+});
+multioauth
+    .command('multioauth xai remove <indexOrEmail>', 'Remove an xAI OAuth account from the rotation pool')
+    .action(async (indexOrEmail) => {
+    const store = await loadXAIAccountStore();
+    const resolvedIndex = resolveAccountIndex(indexOrEmail, store.accounts);
+    if (resolvedIndex < 0) {
+        console.error('Usage: kimaki multioauth xai remove <index-or-email>');
+        process.exit(EXIT_NO_RESTART);
+    }
+    const removed = store.accounts[resolvedIndex];
+    await removeXAIAccount(resolvedIndex);
+    console.log(`Removed xAI account ${removed ? xaiAccountLabel(removed, resolvedIndex) : indexOrEmail}`);
+    process.exit(0);
+});
+multioauth
+    .command('multioauth xai check', 'Test all xAI OAuth accounts for usage limits')
+    .action(async () => {
+    const store = await loadXAIAccountStore();
+    if (store.accounts.length === 0) {
+        console.log('No xAI OAuth accounts configured.');
+        process.exit(0);
+    }
+    console.log('Checking usage limits for all xAI accounts...\n');
+    for (let i = 0; i < store.accounts.length; i++) {
+        const account = store.accounts[i];
+        if (!account)
+            continue;
+        const marker = i === store.activeIndex ? '*' : ' ';
+        const label = account.email ?? account.accountId ?? 'unknown';
+        process.stdout.write(`${marker} ${i + 1}. ${label}: `);
+        // Refresh token if expired
+        let accessToken = account.access;
+        if (account.expires < Date.now()) {
+            try {
+                const response = await fetch('https://auth.x.ai/oauth2/token', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                    body: new URLSearchParams({
+                        grant_type: 'refresh_token',
+                        refresh_token: account.refresh,
+                        client_id: 'b1a00492-073a-47ea-816f-4c329264a828',
+                    }).toString(),
+                });
+                if (!response.ok) {
+                    console.log('ERROR - Token expired, refresh failed');
+                    continue;
+                }
+                const json = (await response.json());
+                accessToken = json.access_token;
+                account.access = accessToken;
+                // xAI can rotate refresh tokens; store the new one if returned
+                if (json.refresh_token)
+                    account.refresh = json.refresh_token;
+                account.expires = Date.now() + (json.expires_in ?? 3600) * 1000;
+            }
+            catch {
+                console.log('ERROR - Token expired, refresh failed');
+                continue;
+            }
+        }
+        try {
+            const response = await fetch('https://api.x.ai/v1/chat/completions', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${accessToken}`,
+                },
+                body: JSON.stringify({
+                    model: 'grok-3-mini',
+                    max_tokens: 1,
+                    messages: [{ role: 'user', content: 'hi' }],
+                }),
+            });
+            if (response.ok) {
+                console.log('OK');
+                continue;
+            }
+            const text = await response.text();
+            const isLimited = text.includes('usage limit') ||
+                text.includes('rate limit') ||
+                text.includes('usage_limit') ||
+                text.includes('balance exhausted') ||
+                response.status === 429 ||
+                response.status === 402;
+            if (isLimited) {
+                let resetInfo;
+                try {
+                    const json = JSON.parse(text);
+                    const match = json.error?.message?.match(/try again (after|in) ([^.]+)/i);
+                    if (match)
+                        resetInfo = match[2];
+                }
+                catch { }
+                console.log(`LIMITED${resetInfo ? ` (resets ${resetInfo})` : ''}`);
+            }
+            else if (response.status === 401) {
+                console.log('ERROR - Auth failed (token invalid)');
+            }
+            else {
+                console.log(`ERROR - ${response.status}: ${text.slice(0, 100)}`);
+            }
+        }
+        catch (err) {
+            console.log(`ERROR - ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    await saveXAIAccountStore(store);
+    process.exit(0);
+});
 export default multioauth;

package/dist/commands/queue.js

@@ -114,6 +114,70 @@ export async function handleQueueCommand({ command, appId, }) {
         flags: SILENT_MESSAGE_FLAGS,
     });
 }
+export async function handleClearQueueCommand({ command, }) {
+    const channel = command.channel;
+    const position = command.options.getInteger('position') ?? undefined;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await command.reply({
+            content: 'This command can only be used in a thread',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const runtime = getRuntime(channel.id);
+    const queueLength = runtime?.getQueueLength() ?? 0;
+    if (queueLength === 0) {
+        await command.reply({
+            content: 'No messages in queue',
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    if (position !== undefined) {
+        const removed = runtime?.removeQueuePosition(position);
+        if (!removed) {
+            await command.reply({
+                content: `No queued message at position ${position}`,
+                flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+            });
+            return;
+        }
+        await command.reply({
+            content: `Cleared queued message at position ${position}`,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        logger.log(`[QUEUE] User ${command.user.displayName} cleared queued position ${position} in thread ${channel.id}`);
+        return;
+    }
+    const cleared = runtime?.clearQueue() ?? [];
+    const lines = cleared.map((item, i) => {
+        const label = item.command
+            ? `/${item.command.name}`
+            : item.prompt;
+        return `${i + 1}. ${label}`;
+    });
+    let list = lines.join('\n');
+    if (list.length > 600) {
+        list = list.slice(0, 597) + '...';
+    }
+    await command.reply({
+        content: `Cleared ${cleared.length} queued message${cleared.length > 1 ? 's' : ''}:\n${list}`,
+        flags: SILENT_MESSAGE_FLAGS,
+    });
+    logger.log(`[QUEUE] User ${command.user.displayName} cleared queue in thread ${channel.id}`);
+}
 export async function handleQueueCommandCommand({ command, appId, }) {
     const commandName = command.options.getString('command', true);
     const args = command.options.getString('arguments') || '';

package/dist/commands/tasks.js

@@ -222,6 +222,12 @@ async function handleRunTaskAction({ interaction, taskId, showAll, }) {
         if (result.kind === 'skipped') {
             return `Task #${taskId} is already running or was claimed elsewhere.`;
         }
+        if (result.kind === 'condition-not-met') {
+            return `Task #${taskId} pre-run condition did not pass.`;
+        }
+        if (result.kind === 'concurrency-blocked') {
+            return `Task #${taskId} still has an active session.`;
+        }
         if (result.kind === 'failed') {
             return `Task #${taskId} failed: ${result.error.message}`;
         }

package/dist/commands/unset-model.js

@@ -8,27 +8,9 @@ import * as schema from '../schema.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
 import { getRuntime } from '../session-handler/thread-session-runtime.js';
-import { getCurrentModelInfo } from './model.js';
+import { formatModelSource, getCurrentModelInfo } from './model.js';
 import { createLogger, LogPrefix } from '../logger.js';
 const unsetModelLogger = createLogger(LogPrefix.MODEL);
-function formatModelSource(type, agentName) {
-    switch (type) {
-        case 'session':
-            return 'session override';
-        case 'agent':
-            return `agent "${agentName}"`;
-        case 'channel':
-            return 'channel override';
-        case 'global':
-            return 'global default';
-        case 'opencode-config':
-        case 'opencode-recent':
-        case 'opencode-provider-default':
-            return 'opencode default';
-        default:
-            return 'none';
-    }
-}
 /**
  * Clear the nearest model override for the current channel/thread.
  * In thread: clears session override if exists, otherwise channel override.
@@ -110,7 +92,10 @@ export async function clearModelOverride({ channel, appId, editReply, }) {
         newModelText =
             newModelInfo.type === 'none'
                 ? 'none'
-                : `\`${newModelInfo.model}\` (${formatModelSource(newModelInfo.type, agentName)})`;
+                : `\`${newModelInfo.model}\` (${formatModelSource({
+                    type: newModelInfo.type,
+                    agentName,
+                })})`;
     }
     // Check if there's a running request and abort+retry with new model (only for session changes in threads)
     let retried = false;