kimaki 0.13.1 → 0.15.0

package/dist/cli-commands/send.js

@@ -138,12 +138,6 @@ cli
             if (options.user) {
                 incompatibleFlags.push('--user');
             }
-            if (!sendAt && options.agent) {
-                incompatibleFlags.push('--agent');
-            }
-            if (!sendAt && options.model) {
-                incompatibleFlags.push('--model');
-            }
             if (incompatibleFlags.length > 0) {
                 cliLogger.error(`Incompatible options with --thread/--session: ${incompatibleFlags.join(', ')}`);
                 process.exit(EXIT_NO_RESTART);
@@ -313,6 +307,8 @@ cli
             }
             const threadPromptMarker = {
                 start: true,
+                ...(options.agent && { agent: options.agent }),
+                ...(options.model && { model: options.model }),
                 ...(options.permission?.length ? { permissions: options.permission } : {}),
                 ...(options.injectionGuard?.length ? { injectionGuardPatterns: options.injectionGuard } : {}),
             };
@@ -334,8 +330,12 @@ cli
                 rest,
             });
             const threadUrl = `https://discord.com/channels/${threadData.guild_id}/${threadData.id}`;
-            note(`Prompt sent to thread: ${threadData.name}\n\nURL: ${threadUrl}`, '✅ Message Sent');
-            cliLogger.log(threadUrl);
+            const existingSessionId = sessionId || await getThreadSession(targetThreadId);
+            const sessionLine = existingSessionId ? `Session: ${existingSessionId}\n` : '';
+            note(`Prompt sent to thread: ${threadData.name}\n${sessionLine}\nURL: ${threadUrl}`, '✅ Message Sent');
+            if (existingSessionId)
+                process.stdout.write(`Session: ${existingSessionId}\n`);
+            process.stdout.write(`${threadUrl}\n`);
             if (options.wait) {
                 const { waitAndOutputSession } = await import('../wait-session.js');
                 await waitAndOutputSession({
@@ -353,16 +353,18 @@ cli
         // Get channel info to extract directory from topic
         const channelData = (await rest.get(Routes.channel(channelId)));
         const channelConfig = await getChannelDirectory(channelData.id);
-        if (!channelConfig) {
+        if (!channelConfig && !notifyOnly) {
             cliLogger.log('Channel not configured');
             throw new Error(`Channel #${channelData.name} is not configured with a project directory. Run the bot first to sync channel data.`);
         }
-        const projectDirectory = channelConfig.directory;
+        const projectDirectory = channelConfig?.directory;
         // Validate --cwd is inside the project or an existing git worktree.
         let resolvedCwd;
         if (options.cwd) {
+            // projectDirectory is guaranteed here: --cwd is incompatible with --notify-only,
+            // and non-notify sends already require channelConfig above.
             const cwdResult = await resolveSessionWorkingDirectory({
-                projectDirectory,
+                projectDirectory: projectDirectory,
                 candidatePath: options.cwd,
             });
             if (cwdResult instanceof Error) {
@@ -456,6 +458,14 @@ cli
             embeds: autoStartEmbed,
             rest,
         });
+        // For notify-only on non-project channels, just post the message without
+        // creating a thread. There's no session to start, so a thread is unnecessary.
+        if (notifyOnly && !channelConfig) {
+            const messageUrl = `https://discord.com/channels/${channelData.guild_id}/${channelId}/${starterMessage.id}`;
+            note(`Channel: #${channelData.name}\n\nMessage sent.\n\nURL: ${messageUrl}`, '✅ Message Sent');
+            process.stdout.write(`${messageUrl}\n`);
+            process.exit(0);
+        }
         cliLogger.log('Creating thread...');
         const threadData = (await rest.post(Routes.threads(channelId, starterMessage.id), {
             body: {
@@ -470,21 +480,41 @@ cli
             await rest.put(Routes.threadMembers(threadData.id, resolvedUser.id));
         }
         const threadUrl = `https://discord.com/channels/${channelData.guild_id}/${threadData.id}`;
+        // Poll for session ID if the bot is expected to auto-start (not --notify-only).
+        // The bot picks up the thread and creates a session asynchronously;
+        // we wait briefly so the caller can reference the session immediately.
+        let newSessionId;
+        if (!notifyOnly) {
+            const { waitForSessionId } = await import('../wait-session.js');
+            newSessionId = await waitForSessionId({
+                threadId: threadData.id,
+                timeoutMs: 15_000,
+            }).catch((e) => {
+                cliLogger.warn(`Could not resolve session ID: ${e instanceof Error ? e.message : String(e)}`);
+                return undefined;
+            });
+        }
         const worktreeNote = worktreeName
             ? `\nWorktree: ${worktreeName} (will be created by bot)`
             : resolvedCwd
                 ? `\nWorking directory: ${resolvedCwd}`
                 : '';
+        const sessionLine = newSessionId ? `\nSession: ${newSessionId}` : '';
+        const directoryLine = projectDirectory ? `\nDirectory: ${projectDirectory}` : '';
         const successMessage = notifyOnly
-            ? `Thread: ${threadData.name}\nDirectory: ${projectDirectory}\n\nNotification created. Reply to start a session.\n\nURL: ${threadUrl}`
-            : `Thread: ${threadData.name}\nDirectory: ${projectDirectory}${worktreeNote}\n\nThe running bot will pick this up and start the session.\n\nURL: ${threadUrl}`;
+            ? `Thread: ${threadData.name}${directoryLine}\n\nNotification created. Reply to start a session.\n\nURL: ${threadUrl}`
+            : `Thread: ${threadData.name}${directoryLine}${worktreeNote}${sessionLine}\n\nThe running bot will pick this up and start the session.\n\nURL: ${threadUrl}`;
         note(successMessage, '✅ Thread Created');
-        cliLogger.log(threadUrl);
+        if (newSessionId)
+            process.stdout.write(`Session: ${newSessionId}\n`);
+        process.stdout.write(`${threadUrl}\n`);
         if (options.wait) {
+            // projectDirectory is guaranteed here: --wait is incompatible with --notify-only,
+            // and non-notify sends already require channelConfig above.
             const { waitAndOutputSession } = await import('../wait-session.js');
             await waitAndOutputSession({
                 threadId: threadData.id,
-                projectDirectory,
+                projectDirectory: projectDirectory,
                 waitStartedAtMs,
             });
         }

package/dist/cli-commands/session.js

@@ -166,9 +166,8 @@ cli
             const dir = project.worktree;
             cliLogger.log(`Trying project: ${dir}`);
             const otherClient = await initializeOpencodeForDirectory(dir);
-            if (otherClient instanceof Error) {
+            if (otherClient instanceof Error)
                 continue;
-            }
             const otherMarkdown = new ShareMarkdown(otherClient());
             const otherResult = await otherMarkdown.generate({
                 sessionID: sessionId,
@@ -387,15 +386,12 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
     const parsedRows = rows.flatMap((row) => {
-        const parsed = errore.try({
-            try: () => {
-                return JSON.parse(row.event_json);
-            },
-            catch: (error) => {
-                return new Error('Failed to parse persisted event JSON', {
-                    cause: error,
-                });
-            },
+        const parsed = errore.try(() => {
+            return JSON.parse(row.event_json);
+        }, (error) => {
+            return new Error('Failed to parse persisted event JSON', {
+                cause: error,
+            });
         });
         if (parsed instanceof Error) {
             cliLogger.warn(`Skipping invalid persisted event row ${row.id}: ${parsed.message}`);
@@ -499,6 +495,52 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
 });
+cli
+    .command('session abort <sessionId>', 'Abort a running session without archiving the thread')
+    .action(async (sessionId) => {
+    try {
+        await initDatabase();
+        const { token: botToken } = await resolveBotCredentials();
+        const rest = createDiscordRest(botToken);
+        // Try to resolve the project directory for the OpenCode abort call
+        const directory = await resolveSessionDirectoryFromDatabase({ sessionId });
+        if (directory instanceof Error) {
+            cliLogger.error(directory.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const serverResult = await initializeOpencodeForDirectory(directory);
+        if (serverResult instanceof Error) {
+            cliLogger.error(`Failed to initialize OpenCode: ${serverResult.message}`);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const client = serverResult();
+        // Don't pass directory — the server resolves sessions by ID regardless
+        // of the x-opencode-directory header, matching archiveThread's pattern.
+        // This avoids issues when --cwd was used (session directory != project directory).
+        const abortResult = await client.session.abort({
+            sessionID: sessionId,
+        }).catch((e) => new Error('Failed to abort session', { cause: e }));
+        if (abortResult instanceof Error) {
+            cliLogger.error(abortResult.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        // Post a message in the Discord thread so it's clear why the session stopped
+        const threadId = await getThreadIdBySessionId(sessionId);
+        if (threadId) {
+            await rest.post(Routes.channelMessages(threadId), {
+                body: { content: 'Session aborted via CLI' },
+            }).catch((e) => {
+                cliLogger.warn(`Could not post abort message to thread: ${e instanceof Error ? e.message : String(e)}`);
+            });
+        }
+        note(`Aborted session: ${sessionId}${threadId ? `\nThread ID: ${threadId}` : ''}`, '✅ Aborted');
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
 cli
     .command('session discord-url <sessionId>', 'Print the Discord thread URL for a session')
     .option('--json', 'Output as JSON')

package/dist/cli.js

@@ -40,6 +40,7 @@ cli
     .option('--no-critique', 'Disable automatic diff upload to critique.work in system prompts')
     .option('--auto-restart', 'Automatically restart the bot on crash or OOM kill')
     .option('--allow-all-users', 'Allow all Discord users to start sessions without needing Kimaki role or admin permissions (no-kimaki role still blocks)')
+    .option('--permission-timeout-minutes <minutes>', 'Permission prompt timeout in minutes before auto-rejecting (default: 10)')
     .option('--disable-sync', 'Disable background sync of external OpenCode sessions into Discord')
     .option('--no-sentry', 'Disable Sentry error reporting')
     .option('--gateway', 'Force gateway mode (use the gateway Kimaki bot instead of a self-hosted bot)')
@@ -134,6 +135,19 @@ cli
                 }
             }
         }
+        // --permission-timeout-minutes validation
+        // Node setTimeout max is 2_147_483_647ms; larger values fire immediately.
+        const MAX_TIMEOUT_MINUTES = Math.floor(2_147_483_647 / 60_000);
+        const permissionTimeoutMs = (() => {
+            if (!options.permissionTimeoutMinutes)
+                return undefined;
+            const parsed = Number(options.permissionTimeoutMinutes);
+            if (!Number.isInteger(parsed) || parsed <= 0 || parsed > MAX_TIMEOUT_MINUTES) {
+                cliLogger.error(`Invalid permission timeout: ${options.permissionTimeoutMinutes}. Must be a positive whole number of minutes (max ${MAX_TIMEOUT_MINUTES}).`);
+                process.exit(EXIT_NO_RESTART);
+            }
+            return parsed * 60_000;
+        })();
         store.setState({
             ...(defaultVerbosity && {
                 defaultVerbosity,
@@ -141,6 +155,7 @@ cli
             ...(options.mentionMode && { defaultMentionMode: true }),
             ...(options.noCritique && { critiqueEnabled: false }),
             ...(options.allowAllUsers && { allowAllUsers: true }),
+            ...(permissionTimeoutMs !== undefined && { permissionTimeoutMs }),
             ...(options.disableSync && { syncEnabled: false }),
             ...(enabledSkills.length > 0 && { enabledSkills }),
             ...(disabledSkills.length > 0 && { disabledSkills }),
@@ -155,6 +170,9 @@ cli
         if (options.allowAllUsers) {
             cliLogger.log('Allow all users: any Discord member can start sessions (no-kimaki role still blocks)');
         }
+        if (permissionTimeoutMs !== undefined) {
+            cliLogger.log(`Permission timeout set to ${options.permissionTimeoutMinutes} minutes`);
+        }
         if (options.verbosity) {
             cliLogger.log(`Default verbosity: ${options.verbosity}`);
         }

package/dist/commands/abort.js

@@ -1,7 +1,7 @@
 // /abort command - Abort the current OpenCode request in this thread.
 import { ChannelType, MessageFlags, } from 'discord.js';
 import { getThreadSession } from '../database.js';
-import { initializeOpencodeForDirectory } from '../opencode.js';
+import { getOpencodeClient, initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { getRuntime } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
@@ -35,7 +35,7 @@ export async function handleAbortCommand({ command, }) {
         await command.editReply('Could not determine project directory for this channel');
         return;
     }
-    const { projectDirectory } = resolved;
+    const { projectDirectory, workingDirectory } = resolved;
     const sessionId = await getThreadSession(channel.id);
     if (!sessionId) {
         await command.editReply('No active session in this thread');
@@ -48,13 +48,16 @@ export async function handleAbortCommand({ command, }) {
     }
     else {
         // No runtime but session exists — fall back to direct API abort
-        const getClient = await initializeOpencodeForDirectory(projectDirectory);
-        if (getClient instanceof Error) {
-            await command.editReply(`Failed to abort: ${getClient.message}`);
+        const serverResult = await initializeOpencodeForDirectory(projectDirectory);
+        if (serverResult instanceof Error) {
+            await command.editReply(`Failed to abort: ${serverResult.message}`);
             return;
         }
         try {
-            await getClient().session.abort({ sessionID: sessionId });
+            const client = getOpencodeClient(workingDirectory);
+            if (client) {
+                await client.session.abort({ sessionID: sessionId, directory: workingDirectory });
+            }
         }
         catch (error) {
             logger.error('[ABORT] API abort failed:', error);

package/dist/commands/action-buttons.js

@@ -212,7 +212,9 @@ export async function handleActionButton(interaction) {
         content: `**Action Required**\n_Selected: ${button.label}_`,
         components: [],
     });
+    const username = interaction.user.globalName || interaction.user.username;
     const prompt = `User clicked: ${button.label}`;
+    await sendThreadMessage(thread, `» **${username}:** ${button.label}`);
     try {
         await sendClickedActionToModel({
             interaction,

package/dist/commands/add-dir.js

@@ -132,7 +132,7 @@ export async function handleAddDirCommand({ command, }) {
         await command.editReply(`Failed to update session permissions: ${getClient.message}`);
         return;
     }
-    const client = getOpencodeClient(resolvedDirectories.projectDirectory);
+    const client = getOpencodeClient(resolvedDirectories.workingDirectory);
     if (!client) {
         await command.editReply('Failed to get OpenCode client');
         return;

package/dist/commands/ask-question.js

@@ -183,6 +183,8 @@ export async function handleAskQuestionSelectMenu(interaction) {
         content: `**${question.header}**\n${question.question}\n✓ _${answeredText}_`,
         components: [], // Remove the dropdown
     });
+    const username = interaction.user.globalName || interaction.user.username;
+    await sendThreadMessage(context.thread, `» **${username}:** ${answeredText}`);
     // Check if all questions are answered
     if (context.answeredCount >= context.totalQuestions) {
         // All questions answered - send result back to session

package/dist/commands/btw.js

@@ -10,41 +10,52 @@ import { createLogger, LogPrefix } from '../logger.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 const logger = createLogger(LogPrefix.FORK);
 export async function forkSessionToBtwThread({ sourceThread, projectDirectory, prompt, userId, username, appId, }) {
-    const sessionId = await getThreadSession(sourceThread.id);
+    // Parallelize: session lookup + opencode init + parent channel resolve are independent
+    const [sessionId, getClientResult, textChannel] = await Promise.all([
+        getThreadSession(sourceThread.id),
+        initializeOpencodeForDirectory(projectDirectory),
+        resolveTextChannel(sourceThread),
+    ]);
     if (!sessionId) {
         return new Error('No active session in this thread');
     }
-    const getClient = await initializeOpencodeForDirectory(projectDirectory);
-    if (getClient instanceof Error) {
-        return new Error(`Failed to fork session: ${getClient.message}`, {
-            cause: getClient,
+    if (getClientResult instanceof Error) {
+        return new Error(`Failed to fork session: ${getClientResult.message}`, {
+            cause: getClientResult,
         });
     }
-    const forkResponse = await getClient().session.fork({
-        sessionID: sessionId,
-    });
-    if (!forkResponse.data) {
-        return new Error('Failed to fork session');
-    }
-    const textChannel = await resolveTextChannel(sourceThread);
     if (!textChannel) {
         return new Error('Could not resolve parent text channel');
     }
+    // Fork must succeed before creating the Discord thread to avoid orphan threads
+    const forkResponse = await getClientResult().session.fork({ sessionID: sessionId });
+    if (!forkResponse.data) {
+        return new Error('Failed to fork session');
+    }
     const forkedSession = forkResponse.data;
     const thread = await textChannel.threads.create({
         name: `btw: ${prompt}`.slice(0, 100),
         autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
         reason: `btw fork from session ${sessionId}`,
     });
+    // DB mapping must complete before user-visible actions so the thread is routable
     await setThreadSession(thread.id, forkedSession.id);
-    await thread.members.add(userId);
-    logger.log(`Created btw fork session ${forkedSession.id} in thread ${thread.id} from ${sessionId}`);
+    // Parallelize: member add and status message are independent best-effort actions
     const sourceThreadLink = `<#${sourceThread.id}>`;
-    await sendThreadMessage(thread, `Reusing context from ${sourceThreadLink} to answer prompt...\n${prompt}`);
+    await Promise.all([
+        thread.members.add(userId).catch(() => { }),
+        sendThreadMessage(thread, `Reusing context from ${sourceThreadLink} to answer prompt...\n${prompt}`),
+    ]);
+    logger.log(`Created btw fork session ${forkedSession.id} in thread ${thread.id} from source thread ${sourceThread.id} (session ${sessionId})`);
     const wrappedPrompt = [
         `The user asked a side question while you were working on another task.`,
         `This is a forked session whose ONLY goal is to answer this question.`,
-        `Do NOT continue, resume, or reference the previous task. Only answer the question below.\n`,
+        `Do NOT continue, resume, or reference the previous task. Only answer the question below.`,
+        ``,
+        `Parent session: ${sessionId} (thread <#${sourceThread.id}>)`,
+        `If the user asks you to send a message or follow-up to the parent session, use:`,
+        `  kimaki send --session ${sessionId} --prompt 'your message here'`,
+        ``,
         prompt,
     ].join('\n');
     const runtime = getOrCreateRuntime({

package/dist/commands/compact.js

@@ -54,7 +54,7 @@ export async function handleCompactCommand({ command, }) {
         });
         return;
     }
-    const client = getOpencodeClient(projectDirectory);
+    const client = getOpencodeClient(workingDirectory);
     if (!client) {
         await command.reply({
             content: 'Failed to get OpenCode client',

package/dist/commands/context-usage.js

@@ -1,10 +1,10 @@
 // /context-usage command - Show token usage and context window percentage for the current session.
 import { ChannelType, MessageFlags, } from 'discord.js';
+import { OpenCodeSdkError } from '../errors.js';
 import { getThreadSession } from '../database.js';
-import { initializeOpencodeForDirectory } from '../opencode.js';
+import { getOpencodeClient, initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
-import * as errore from 'errore';
 const logger = createLogger(LogPrefix.SESSION);
 function getTokenTotal({ input, output, reasoning, cache, }) {
     return input + output + reasoning + cache.read + cache.write;
@@ -49,17 +49,25 @@ export async function handleContextUsageCommand({ command, }) {
         });
         return;
     }
-    const getClient = await initializeOpencodeForDirectory(projectDirectory);
-    if (getClient instanceof Error) {
+    const serverResult = await initializeOpencodeForDirectory(projectDirectory);
+    if (serverResult instanceof Error) {
         await command.reply({
-            content: `Failed to get context usage: ${getClient.message}`,
+            content: `Failed to get context usage: ${serverResult.message}`,
+            flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const client = getOpencodeClient(workingDirectory);
+    if (!client) {
+        await command.reply({
+            content: 'Failed to get OpenCode client',
             flags: MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS,
         });
         return;
     }
     await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
     try {
-        const messagesResponse = await getClient().session.messages({
+        const messagesResponse = await client.session.messages({
             sessionID: sessionId,
             directory: workingDirectory,
         });
@@ -98,9 +106,8 @@ export async function handleContextUsageCommand({ command, }) {
         }, 0);
         // Fetch model context limit from provider API
         let contextLimit;
-        const providersResult = await errore.tryAsync(() => {
-            return getClient().provider.list({ directory: workingDirectory });
-        });
+        const providersResult = await client.provider.list({ directory: workingDirectory })
+            .catch((e) => new OpenCodeSdkError({ operation: 'provider.list', cause: e }));
         if (providersResult instanceof Error) {
             logger.error('[CONTEXT-USAGE] Failed to fetch provider info:', providersResult);
         }

package/dist/commands/file-upload.js

@@ -11,7 +11,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { createLogger, LogPrefix } from '../logger.js';
 import { notifyError } from '../sentry.js';
-import { NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js';
+import { NOTIFY_MESSAGE_FLAGS, sendThreadMessage } from '../discord-utils.js';
 const logger = createLogger(LogPrefix.FILE_UPLOAD);
 // 5 minute TTL for pending contexts - if user doesn't click within this time,
 // clean up the context and resolve with empty array to unblock the plugin tool
@@ -219,6 +219,10 @@ export async function handleFileUploadModalSubmit(interaction) {
             return `Upload failed: ${errors.join('; ')}`;
         })();
         await interaction.editReply({ content: summary });
+        if (downloadedPaths.length > 0) {
+            const username = interaction.user.globalName || interaction.user.username;
+            await sendThreadMessage(context.thread, `» **${username}:** Uploaded ${fileNames.join(', ')}`);
+        }
         resolveContext(context, downloadedPaths);
         logger.log(`File upload completed for session ${context.sessionId}: ${downloadedPaths.length} files`);
     }

package/dist/commands/fork.js

@@ -27,15 +27,12 @@ function getThreadChannel(channel) {
 }
 function parsePersistedEventRows({ rows, }) {
     return rows.flatMap((row) => {
-        const parsed = errore.try({
-            try: () => {
-                return JSON.parse(row.event_json);
-            },
-            catch: (error) => {
-                return new Error('Failed to parse persisted event JSON', {
-                    cause: error,
-                });
-            },
+        const parsed = errore.try(() => {
+            return JSON.parse(row.event_json);
+        }, (error) => {
+            return new Error('Failed to parse persisted event JSON', {
+                cause: error,
+            });
         });
         if (parsed instanceof Error) {
             forkLogger.warn(`[fork] Skipping invalid persisted event row ${row.id}: ${parsed.message}`);
@@ -230,8 +227,9 @@ export async function handleForkSelectMenu(interaction) {
         await setThreadSession(thread.id, forkedSession.id);
         // Add user to thread so it appears in their sidebar
         await thread.members.add(interaction.user.id);
-        sessionLogger.log(`Created forked session ${forkedSession.id} in thread ${thread.id}`);
-        await sendThreadMessage(thread, `**Forked session created!**\nFrom: \`${sessionId}\`\nNew session: \`${forkedSession.id}\``);
+        const sourceThreadLink = `<#${threadChannel.id}>`;
+        sessionLogger.log(`Created forked session ${forkedSession.id} in thread ${thread.id} from source thread ${threadChannel.id} (session ${sessionId})`);
+        await sendThreadMessage(thread, `**Forked session created!**\nFrom: ${sourceThreadLink} (\`${sessionId}\`)\nNew session: \`${forkedSession.id}\``);
         // Fetch and display the last assistant messages from the forked session
         const messagesResponse = await getClient().session.messages({
             sessionID: forkedSession.id,

package/dist/commands/login.js

@@ -10,7 +10,7 @@
 //   login_text:<hash>    — text prompt modal submission
 import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ModalBuilder, TextInputBuilder, TextInputStyle, ModalSubmitInteraction, ButtonBuilder, ButtonStyle, ChannelType, MessageFlags, } from 'discord.js';
 import crypto from 'node:crypto';
-import { initializeOpencodeForDirectory, getOpencodeServerPort, } from '../opencode.js';
+import { initializeOpencodeForDirectory, getOpencodeServerPort, getOpencodeServerAuthHeaders, } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { buildPaginatedOptions, parsePaginationValue } from './paginated-select.js';
@@ -784,18 +784,11 @@ async function startOAuthFlow(interaction, ctx, hash) {
         const hasInputs = Object.keys(ctx.inputs).length > 0;
         const authorizeUrl = new URL(`/provider/${encodeURIComponent(ctx.providerId)}/oauth/authorize`, `http://127.0.0.1:${port}`);
         authorizeUrl.searchParams.set('directory', ctx.dir);
-        // Include basic auth if OPENCODE_SERVER_PASSWORD is set,
-        // matching the opencode server's optional basicAuth middleware.
         const fetchHeaders = {
             'Content-Type': 'application/json',
             'x-opencode-directory': ctx.dir,
+            ...getOpencodeServerAuthHeaders(),
         };
-        const serverPassword = process.env.OPENCODE_SERVER_PASSWORD;
-        if (serverPassword) {
-            const username = process.env.OPENCODE_SERVER_USERNAME || 'opencode';
-            fetchHeaders['Authorization'] =
-                `Basic ${Buffer.from(`${username}:${serverPassword}`).toString('base64')}`;
-        }
         const authorizeRes = await fetch(authorizeUrl, {
             method: 'POST',
             headers: fetchHeaders,

package/dist/commands/model-variant.js

@@ -7,11 +7,10 @@
 // Map. Whichever menu fires second sees the first selection stored and applies.
 import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, MessageFlags, } from 'discord.js';
 import crypto from 'node:crypto';
-import { setChannelModel, setSessionModel, getThreadSession, setGlobalModel, getVariantCascade, } from '../database.js';
+import { setChannelModel, getThreadSession, setGlobalModel, getVariantCascade, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
-import { getCurrentModelInfo, ensureSessionPreferencesSnapshot, } from './model.js';
-import { getRuntime } from '../session-handler/thread-session-runtime.js';
+import { getCurrentModelInfo, ensureSessionPreferencesSnapshot, applyToCurrentSession, } from './model.js';
 import { getThinkingValuesForModel } from '../thinking-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 const logger = createLogger(LogPrefix.MODEL);
@@ -303,22 +302,14 @@ async function applyVariant({ interaction, context, variant, scope, contextHash,
                 });
                 return;
             }
-            await setSessionModel({
+            const retried = await applyToCurrentSession({
                 sessionId: context.sessionId,
+                thread: context.thread,
                 modelId,
                 variant,
             });
+            const retryNote = retried ? '\n_Restarting current request with new variant..._' : '';
             logger.log(`Set variant ${variant ?? 'none'} for session ${context.sessionId} (model ${modelId})`);
-            let retried = false;
-            if (context.thread) {
-                const runtime = getRuntime(context.thread.id);
-                if (runtime) {
-                    retried = await runtime.retryLastUserPrompt();
-                }
-            }
-            const retryNote = retried
-                ? '\n_Restarting current request with new variant..._'
-                : '';
             await interaction.editReply({
                 content: `Variant set for this session:\n**${context.providerName}** / **${context.modelName}**${variantSuffix}\n\`${modelId}\`${retryNote}${agentTip}`,
                 flags: MessageFlags.SuppressEmbeds,
@@ -332,9 +323,16 @@ async function applyVariant({ interaction, context, variant, scope, contextHash,
                 modelId,
                 variant,
             });
+            const retried = await applyToCurrentSession({
+                sessionId: context.sessionId,
+                thread: context.thread,
+                modelId,
+                variant,
+            });
+            const retryNote = retried ? '\n_Restarting current request with new variant..._' : '';
             logger.log(`Set global variant ${variant ?? 'none'} for app ${context.appId} and channel ${context.channelId} (model ${modelId})`);
             await interaction.editReply({
-                content: `Variant set for this channel and as global default:\n**${context.providerName}** / **${context.modelName}**${variantSuffix}\n\`${modelId}\`\nAll channels will use this variant (unless they have their own override).${agentTip}`,
+                content: `Variant set for this channel and as global default:\n**${context.providerName}** / **${context.modelName}**${variantSuffix}\n\`${modelId}\`\nAll channels will use this variant (unless they have their own override).${retryNote}${agentTip}`,
                 flags: MessageFlags.SuppressEmbeds,
                 components: [],
             });
@@ -346,9 +344,16 @@ async function applyVariant({ interaction, context, variant, scope, contextHash,
                 modelId,
                 variant,
             });
+            const retried = await applyToCurrentSession({
+                sessionId: context.sessionId,
+                thread: context.thread,
+                modelId,
+                variant,
+            });
+            const retryNote = retried ? '\n_Restarting current request with new variant..._' : '';
             logger.log(`Set channel variant ${variant ?? 'none'} for channel ${context.channelId} (model ${modelId})`);
             await interaction.editReply({
-                content: `Variant set for this channel:\n**${context.providerName}** / **${context.modelName}**${variantSuffix}\n\`${modelId}\`\nAll new sessions in this channel will use this variant.${agentTip}`,
+                content: `Variant set for this channel:\n**${context.providerName}** / **${context.modelName}**${variantSuffix}\n\`${modelId}\`\nAll new sessions in this channel will use this variant.${retryNote}${agentTip}`,
                 flags: MessageFlags.SuppressEmbeds,
                 components: [],
             });