kimaki 0.25.0 → 0.26.0

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.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/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;

package/dist/database.js

@@ -95,6 +95,71 @@ export async function claimScheduledTaskRunning({ taskId, startedAt }) {
         .returning({ id: schema.scheduled_tasks.id });
     return countRows(rows) > 0;
 }
+export async function releaseScheduledTaskClaim(taskId) {
+    const db = await getDb();
+    await db.update(schema.scheduled_tasks)
+        .set({ status: 'planned', running_started_at: null })
+        .where(orm.and(orm.eq(schema.scheduled_tasks.id, taskId), orm.eq(schema.scheduled_tasks.status, 'running')));
+}
+export async function createScheduledTaskRun({ taskId, startedAt, }) {
+    const db = await getDb();
+    const [run] = await db.insert(schema.scheduled_task_runs)
+        .values({ scheduled_task_id: taskId, started_at: startedAt })
+        .returning({ id: schema.scheduled_task_runs.id });
+    if (!run)
+        throw new Error(`Failed to create run for scheduled task ${taskId}`);
+    return run.id;
+}
+export async function getActiveScheduledTaskRuns(taskId) {
+    const db = await getDb();
+    return db.query.scheduled_task_runs.findMany({
+        where: {
+            scheduled_task_id: taskId,
+            status: { in: ['pending', 'running'] },
+        },
+        orderBy: { started_at: 'desc' },
+    });
+}
+export async function setScheduledTaskRunThread({ runId, threadId, }) {
+    const db = await getDb();
+    await db.update(schema.scheduled_task_runs)
+        .set({ thread_id: threadId })
+        .where(orm.eq(schema.scheduled_task_runs.id, runId));
+}
+export async function startScheduledTaskRunSession({ runId, sessionId, projectDirectory, }) {
+    const db = await getDb();
+    await db.update(schema.scheduled_task_runs)
+        .set({ status: 'running', session_id: sessionId, project_directory: projectDirectory })
+        .where(orm.and(orm.eq(schema.scheduled_task_runs.id, runId), orm.eq(schema.scheduled_task_runs.status, 'pending')));
+}
+export async function completeScheduledTaskRunsForSession(sessionId) {
+    const db = await getDb();
+    const rows = await db.update(schema.scheduled_task_runs)
+        .set({ status: 'completed', completed_at: new Date() })
+        .where(orm.and(orm.eq(schema.scheduled_task_runs.session_id, sessionId), orm.inArray(schema.scheduled_task_runs.status, ['pending', 'running'])))
+        .returning({ id: schema.scheduled_task_runs.id });
+    return rows.length;
+}
+export async function failScheduledTaskRunsForSession({ sessionId, error, }) {
+    const db = await getDb();
+    const rows = await db.update(schema.scheduled_task_runs)
+        .set({ status: 'failed', completed_at: new Date(), error })
+        .where(orm.and(orm.eq(schema.scheduled_task_runs.session_id, sessionId), orm.inArray(schema.scheduled_task_runs.status, ['pending', 'running'])))
+        .returning({ id: schema.scheduled_task_runs.id });
+    return rows.length;
+}
+export async function failScheduledTaskRun({ runId, error, }) {
+    const db = await getDb();
+    await db.update(schema.scheduled_task_runs)
+        .set({ status: 'failed', completed_at: new Date(), error })
+        .where(orm.eq(schema.scheduled_task_runs.id, runId));
+}
+export async function finishScheduledTaskRun({ runId, status, }) {
+    const db = await getDb();
+    await db.update(schema.scheduled_task_runs)
+        .set({ status, completed_at: new Date() })
+        .where(orm.eq(schema.scheduled_task_runs.id, runId));
+}
 export async function recoverStaleRunningScheduledTasks({ staleBefore }) {
     const db = await getDb();
     const rows = await db.update(schema.scheduled_tasks)

package/dist/discord-bot.js

@@ -142,11 +142,15 @@ function parseSessionStartSourceFromMarker(marker) {
     if (typeof marker.scheduledTaskId !== 'number' ||
         !Number.isInteger(marker.scheduledTaskId) ||
         marker.scheduledTaskId < 1) {
-        return { scheduleKind: marker.scheduledKind };
+        return {
+            scheduleKind: marker.scheduledKind,
+            scheduledTaskRunId: marker.scheduledTaskRunId,
+        };
     }
     return {
         scheduleKind: marker.scheduledKind,
         scheduledTaskId: marker.scheduledTaskId,
+        scheduledTaskRunId: marker.scheduledTaskRunId,
     };
 }
 export async function createDiscordClient() {
@@ -632,6 +636,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                         ? {
                             scheduleKind: sessionStartSource.scheduleKind,
                             scheduledTaskId: sessionStartSource.scheduledTaskId,
+                            scheduledTaskRunId: sessionStartSource.scheduledTaskRunId,
                         }
                         : undefined,
                     preprocess: () => {
@@ -1085,6 +1090,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     ? {
                         scheduleKind: botThreadStartSource.scheduleKind,
                         scheduledTaskId: botThreadStartSource.scheduledTaskId,
+                        scheduledTaskRunId: botThreadStartSource.scheduledTaskRunId,
                     }
                     : undefined,
                 preprocess: async () => {

package/dist/ipc-tools-plugin.js

@@ -56,7 +56,7 @@ const ipcToolsPlugin = async () => {
                     'The user sees a button, clicks it, and gets a file upload dialog. ' +
                     'Returns the local file paths of downloaded files in the project directory. ' +
                     'Use this when you need the user to provide files (images, documents, configs, etc.). ' +
-                    'IMPORTANT: Always call this tool last in your message, after all text parts.',
+                    'You MUST call kimaki_file_upload LAST, after ALL text. NEVER call it before your text.',
                 args: {
                     prompt: z
                         .string()
@@ -115,8 +115,9 @@ const ipcToolsPlugin = async () => {
           Use this when the user can respond by clicking one of up to 3 buttons.
           Prefer a single button whenever possible.
           Default color is white (same visual style as permission deny button).
-          If you need more than 3 options, use the question tool instead.
-          IMPORTANT: Always call this tool last in your message, after all text parts.
+          If you need more than 3 options, use \`question\` instead.
+          You MUST call kimaki_action_buttons LAST, after ALL text.
+          NEVER call kimaki_action_buttons before your text.
 
           Examples:
           - buttons: [{"label":"Yes, proceed"}]

package/dist/kimaki-opencode-plugin.js

@@ -15,6 +15,8 @@ export { contextAwarenessPlugin } from './context-awareness-plugin.js';
 export { memoryOverviewPlugin } from './memory-overview-plugin.js';
 export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plugin.js';
 export { anthropicAuthPlugin } from './anthropic-auth-plugin.js';
+export { openaiRotationPlugin } from './openai-auth-plugin.js';
+export { xaiRotationPlugin } from './xai-auth-plugin.js';
 export { imageOptimizerPlugin } from './image-optimizer-plugin.js';
 export { subagentRateLimitPlugin } from './subagent-rate-limit-plugin.js';
 export { cacheDriftPlugin } from './cache-drift-plugin.js';