kimaki 0.26.0 → 0.27.0

package/dist/commands/ask-question.js

@@ -5,11 +5,13 @@ import { StringSelectMenuBuilder, StringSelectMenuInteraction, ActionRowBuilder,
 import crypto from 'node:crypto';
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
 import { getOpencodeClient } from '../opencode.js';
+import { DiscordOperationError } from '../errors.js';
 import { createLogger, LogPrefix } from '../logger.js';
 const logger = createLogger(LogPrefix.ASK_QUESTION);
 // Store pending question contexts by hash.
-// TTL prevents unbounded growth if user never answers a question.
-const QUESTION_CONTEXT_TTL_MS = 10 * 60 * 1000;
+// No TTL on purpose: a question can only be answered by the user, so expiring it
+// could only abort the run. Cleanup happens on answer, on a new user message, on
+// abort (abortActiveRunInternal), and on thread dispose.
 export const pendingQuestionContexts = new Map();
 export function areAllQuestionsAnswered({ totalQuestions, answers, }) {
     for (let i = 0; i < totalQuestions; i++) {
@@ -75,32 +77,6 @@ export async function showAskUserQuestionDropdowns({ thread, sessionId, director
         contextHash,
     };
     pendingQuestionContexts.set(contextHash, context);
-    // On TTL expiry: hide the dropdown UI and abort the session so OpenCode
-    // unblocks. We intentionally do NOT call question.reply() — sending 'Other'
-    // made the model think the user chose an option when they didn't.
-    setTimeout(async () => {
-        const ctx = pendingQuestionContexts.get(contextHash);
-        if (!ctx) {
-            return;
-        }
-        // Delete context first so the dropdown becomes inert immediately.
-        // Without this, a user clicking during the abort() await would still
-        // be accepted by handleAskQuestionSelectMenu, then abort() would
-        // kill that valid run.
-        deletePendingQuestionContextsForRequest({
-            threadId: ctx.thread.id,
-            requestId: ctx.requestId,
-        });
-        // Abort the session so OpenCode isn't stuck waiting for a reply
-        const client = getOpencodeClient(ctx.directory);
-        if (client) {
-            await client.session.abort({
-                sessionID: ctx.sessionId,
-            }).catch((error) => {
-                logger.error('Failed to abort session after question expiry:', error);
-            });
-        }
-    }, QUESTION_CONTEXT_TTL_MS).unref();
     // Send one message per question with its dropdown directly underneath
     for (let i = 0; i < input.questions.length; i++) {
         const q = input.questions[i];
@@ -129,11 +105,24 @@ export async function showAskUserQuestionDropdowns({ thread, sessionId, director
             selectMenu.setMaxValues(options.length);
         }
         const actionRow = new ActionRowBuilder().addComponents(selectMenu);
-        await thread.send({
+        const sendResult = await thread.send({
             content: `**${(q.header || '').slice(0, 200)}**\n${q.question.slice(0, 1700)}`,
             components: [actionRow],
             flags: silent ? SILENT_MESSAGE_FLAGS : NOTIFY_MESSAGE_FLAGS,
-        });
+        }).catch((e) => new DiscordOperationError({ operation: 'sendQuestionDropdown', cause: e }));
+        // Without a visible dropdown the user can never answer, and there is no TTL
+        // to rescue the run, so drop the context and abort so OpenCode unblocks.
+        if (sendResult instanceof Error) {
+            logger.error('Failed to send question dropdown:', sendResult);
+            deletePendingQuestionContextsForRequest({ threadId: thread.id, requestId });
+            const client = getOpencodeClient(directory);
+            if (client) {
+                await client.session.abort({ sessionID: sessionId }).catch((error) => {
+                    logger.error('Failed to abort session after question send failure:', error);
+                });
+            }
+            return;
+        }
     }
     logger.log(`Showed ${input.questions.length} question dropdown(s) for session ${sessionId}`);
 }
@@ -276,7 +265,7 @@ export function parseAskUserQuestionTool(part) {
  *   the tool answer so the model sees the user's response. The caller should
  *   NOT also enqueue the message as a new prompt.
  *   Returns 'replied' on success, 'reply-failed' if the reply call fails
- *   (context kept pending so TTL can retry).
+ *   (context kept pending so the user can retry).
  */
 export async function cancelPendingQuestion(threadId, userMessage) {
     // Find pending question for this thread
@@ -320,7 +309,7 @@ export async function cancelPendingQuestion(threadId, userMessage) {
     }
     catch (error) {
         logger.error('Failed to answer question:', error);
-        // Keep context pending so TTL can still fire.
+        // Keep context pending so the user can retry.
         // Caller should not consume the user message since reply failed.
         return 'reply-failed';
     }

package/dist/commands/ask-question.test.js

@@ -1,8 +1,11 @@
 // Tests AskUserQuestion request deduplication and cleanup helpers.
 import { afterEach, describe, expect, test, vi } from 'vitest';
 import { areAllQuestionsAnswered, deletePendingQuestionContextsForRequest, pendingQuestionContexts, showAskUserQuestionDropdowns, } from './ask-question.js';
-function createFakeThread() {
+function createFakeThread({ failSend } = {}) {
     const send = vi.fn(async () => {
+        if (failSend) {
+            throw new Error('Missing Permissions');
+        }
         return { id: 'msg-1' };
     });
     return {
@@ -88,6 +91,45 @@ describe('ask-question', () => {
         expect(removed).toBe(2);
         expect([...pendingQuestionContexts.keys()]).toEqual(['ctx-3']);
     });
+    test('does not schedule a question expiry timer', async () => {
+        const timeoutSpy = vi.spyOn(globalThis, 'setTimeout');
+        await showAskUserQuestionDropdowns({
+            thread: createFakeThread(),
+            sessionId: 'ses-1',
+            directory: '/project',
+            requestId: 'req-no-ttl',
+            input: {
+                questions: [{
+                        question: 'Choose one',
+                        header: 'Pick',
+                        options: [
+                            { label: 'Alpha', description: 'A' },
+                            { label: 'Beta', description: 'B' },
+                        ],
+                    }],
+            },
+        });
+        expect(timeoutSpy).not.toHaveBeenCalled();
+    });
+    test('drops the context when the dropdown message fails to send', async () => {
+        await showAskUserQuestionDropdowns({
+            thread: createFakeThread({ failSend: true }),
+            sessionId: 'ses-1',
+            directory: '/project',
+            requestId: 'req-send-fails',
+            input: {
+                questions: [{
+                        question: 'Choose one',
+                        header: 'Pick',
+                        options: [
+                            { label: 'Alpha', description: 'A' },
+                            { label: 'Beta', description: 'B' },
+                        ],
+                    }],
+            },
+        });
+        expect(pendingQuestionContexts.size).toBe(0);
+    });
     test('requires every question to have an answer', () => {
         expect(areAllQuestionsAnswered({
             totalQuestions: 3,

package/dist/commands/login.js

@@ -12,6 +12,7 @@ import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectM
 import crypto from 'node:crypto';
 import { initializeOpencodeForDirectory, getOpencodeServerPort, getOpencodeServerAuthHeaders, } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
+import { clearModelListCache } from '../session-handler/model-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { buildPaginatedOptions, parsePaginationValue } from './paginated-select.js';
 const loginLogger = createLogger(LogPrefix.LOGIN);
@@ -31,7 +32,9 @@ function createContextHash(context) {
 // ── Provider popularity order ───────────────────────────────────
 // Discord select menus cap at 25 options, so we show popular ones first.
 // IDs sourced from opencode's provider.list() API (scripts/list-providers.ts).
+// `subrouter` leads: it pools every subscription and cycles across them.
 const PROVIDER_POPULARITY_ORDER = [
+    'subrouter',
     'anthropic',
     'openai',
     'google',
@@ -691,6 +694,7 @@ export async function handleOAuthCodeModalSubmit(interaction) {
             return;
         }
         await getClient().instance.dispose({ directory: ctx.dir });
+        clearModelListCache();
         pendingLoginContexts.delete(hash);
         await interaction.editReply({
             content: `✅ **Successfully authenticated with ${ctx.providerName}!**\n\nYou can now use models from this provider.`,
@@ -736,6 +740,7 @@ export async function handleApiKeyModalSubmit(interaction) {
         });
         // Dispose to refresh provider state so new credentials are recognized
         await getClient().instance.dispose({ directory: ctx.dir });
+        clearModelListCache();
         await interaction.editReply({
             content: `✅ **Successfully authenticated with ${ctx.providerName}!**\n\nYou can now use models from this provider.`,
         });
@@ -870,6 +875,7 @@ async function startOAuthFlow(interaction, ctx, hash) {
             return;
         }
         await getClient().instance.dispose({ directory: ctx.dir });
+        clearModelListCache();
         pendingLoginContexts.delete(hash);
         await interaction.editReply({
             content: `✅ **Successfully authenticated with ${ctx.providerName}!**\n\nYou can now use models from this provider.`,

package/dist/commands/merge-worktree.js

@@ -1,16 +1,17 @@
-// /merge-worktree command - Merge worktree commits into default branch.
-// Pipeline: rebase worktree commits onto target -> local fast-forward push.
-// Preserves all commits (no squash). On rebase conflicts, asks the AI model
-// in the thread to resolve them.
+// /merge-worktree command - Rebase or squash worktree commits into a target branch.
+// On rebase conflicts, asks the AI model in the thread to resolve them.
 import {} from 'discord.js';
 import { getThreadWorktreeOrWorkspace, getThreadSession, getChannelDirectory, } from '../database.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { notifyError } from '../sentry.js';
-import { mergeWorktree, listBranchesByLastCommit, validateBranchRef } from '../worktrees.js';
+import { mergeWorktree, listBranchesByLastCommit, validateBranchRef, formatMergeWorktreeError, } from '../worktrees.js';
 import { sendThreadMessage, resolveWorkingDirectory, resolveProjectDirectoryFromAutocomplete, } from '../discord-utils.js';
 import { getOrCreateRuntime, } from '../session-handler/thread-session-runtime.js';
 import { RebaseConflictError, DirtyWorktreeError, TargetDirtyWorktreeError, NothingToMergeError, } from '../errors.js';
 const logger = createLogger(LogPrefix.WORKTREE);
+function quoteShellArg(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
 /** Worktree thread title prefix - indicates unmerged worktree */
 export const WORKTREE_PREFIX = '⬦ ';
 async function removeWorktreePrefixFromTitle(thread) {
@@ -73,6 +74,14 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
         await command.editReply(`Worktree is not ready (status: ${info.status})${info.error_message ? `: ${info.error_message}` : ''}`);
         return;
     }
+    const strategyOption = command.options.getString('strategy') || 'rebase';
+    if (strategyOption !== 'rebase' && strategyOption !== 'squash') {
+        await command.editReply(`Invalid merge strategy: \`${strategyOption}\``);
+        return;
+    }
+    const strategyName = strategyOption === 'squash'
+        ? 'Squash into one commit'
+        : 'Keep commits (rebase)';
     const rawTargetBranch = command.options.getString('target-branch') || undefined;
     let targetBranch = rawTargetBranch;
     if (targetBranch) {
@@ -91,6 +100,7 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
         mainRepoDir: info.project_directory,
         worktreeName: info.workspace_name,
         targetBranch,
+        strategy: strategyOption,
         onProgress: (msg) => {
             logger.log(`[merge] ${msg}`);
         },
@@ -106,11 +116,21 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
         }
         if (result instanceof NothingToMergeError) {
             void removeWorktreePrefixFromTitle(thread);
-            await command.editReply(`Merge failed: ${result.message}`);
+            await command.editReply(formatMergeWorktreeError(result));
             return;
         }
         if (result instanceof RebaseConflictError) {
-            await command.editReply('Rebase conflict detected. Asking the model to resolve...');
+            const mergedThreadName = thread.name.startsWith(WORKTREE_PREFIX)
+                ? thread.name.slice(WORKTREE_PREFIX.length)
+                : thread.name;
+            const mergeCommand = [
+                'kimaki merge-worktree',
+                `--strategy ${strategyOption}`,
+                `--target-branch ${quoteShellArg(String(result.target))}`,
+                `--thread ${quoteShellArg(thread.id)}`,
+                `--thread-name ${quoteShellArg(mergedThreadName)}`,
+            ].join(' ');
+            await command.editReply(`Rebase conflict detected. Asking the model to resolve it and retry the merge with **${strategyName}**.`);
             await sendPromptToModel({
                 prompt: [
                     `A rebase conflict occurred while merging this worktree into \`${result.target}\`.`,
@@ -124,7 +144,8 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
                     '6. Stage resolved files with `git add`',
                     '7. Continue the rebase with `git rebase --continue`',
                     '8. If git reports more conflicts, repeat steps 1-7 until the rebase finishes (no more rebase in progress, `git status` is clean)',
-                    '9. Once the rebase is fully complete, tell me so I can run `/merge-worktree` again',
+                    `9. Once the rebase is fully complete, run \`${mergeCommand}\` yourself`,
+                    '10. If that command fails because the target changed or is not ready, stop and report the failure. The user can run it again later.',
                 ].join('\n'),
                 thread,
                 projectDirectory: info.project_directory,
@@ -133,11 +154,16 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
             });
             return;
         }
-        await command.editReply(`Merge failed: ${result.message}`);
+        const formatted = formatMergeWorktreeError(result);
+        logger.error(formatted);
+        await command.editReply(formatted);
         return;
     }
     void removeWorktreePrefixFromTitle(thread);
-    await command.editReply(`Merged \`${result.branchName}\` into \`${result.defaultBranch}\` @ ${result.shortSha} (${result.commitCount} commit${result.commitCount === 1 ? '' : 's'})\nWorktree now at detached HEAD.`);
+    const mergeSummary = strategyOption === 'squash'
+        ? `Squashed \`${result.branchName}\` into \`${result.defaultBranch}\` @ ${result.shortSha} (${result.commitCount} source commit${result.commitCount === 1 ? '' : 's'} → 1)`
+        : `Merged \`${result.branchName}\` into \`${result.defaultBranch}\` @ ${result.shortSha} (${result.commitCount} commit${result.commitCount === 1 ? '' : 's'})`;
+    await command.editReply(`${mergeSummary}\nWorktree now at detached HEAD.`);
 }
 /**
  * Autocomplete handler for /merge-worktree target-branch option.

package/dist/commands/model-variant.js

@@ -13,6 +13,7 @@ import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
 import { getCurrentModelInfo, ensureSessionPreferencesSnapshot, applyToCurrentSession, } from './model.js';
 import { getThinkingValuesForModel } from '../thinking-utils.js';
+import { resolveDisplayedModelId } from '../session-handler/model-utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 const logger = createLogger(LogPrefix.MODEL);
 const pendingVariantContexts = new Map();
@@ -137,6 +138,11 @@ export async function showModelVariantPicker({ channel, appId, editReply, }) {
     const { providerID, modelID, model: fullModelId } = currentModelInfo;
     const sourceLabel = formatSourceLabel(currentModelInfo);
     const variantLabel = cascadeVariant ? ` (${cascadeVariant})` : '';
+    const displayedModelId = resolveDisplayedModelId({
+        providers: providersResponse.data.all,
+        providerID,
+        modelID,
+    }) ?? fullModelId;
     const provider = providersResponse.data.all.find((p) => {
         return p.id === providerID;
     });
@@ -146,7 +152,7 @@ export async function showModelVariantPicker({ channel, appId, editReply, }) {
         providerId: providerID,
         modelId: modelID,
     });
-    const statusText = `**Current model:** \`${fullModelId}\`${variantLabel} — ${sourceLabel}`;
+    const statusText = `**Current model:** \`${displayedModelId}\`${variantLabel} — ${sourceLabel}`;
     if (variants.length === 0) {
         await editReply({
             content: `${statusText}\nThis model doesn't support thinking level variants.`,

package/dist/commands/model.js

@@ -4,7 +4,7 @@ import crypto from 'node:crypto';
 import { setChannelModel, setSessionModel, setSessionAgent, getChannelModel, getSessionModel, getSessionAgent, getChannelAgent, getThreadSession, getGlobalModel, setGlobalModel, getVariantCascade, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
-import { getDefaultModel } from '../session-handler/model-utils.js';
+import { getDefaultModel, resolveDisplayedModelId, } from '../session-handler/model-utils.js';
 import { getRuntime } from '../session-handler/thread-session-runtime.js';
 import { getThinkingValuesForModel } from '../thinking-utils.js';
 import { buildHtmlActionCustomId, cancelHtmlActionsForOwner, registerHtmlAction, } from '../html-actions.js';
@@ -322,21 +322,27 @@ export async function handleModelCommand({ interaction, appId, }) {
             return;
         }
         const currentModelText = (() => {
+            if (currentModelInfo.type === 'none') {
+                return '**Current:** none';
+            }
+            const displayed = resolveDisplayedModelId({
+                providers: allProviders,
+                providerID: currentModelInfo.providerID,
+                modelID: currentModelInfo.modelID,
+            }) ?? currentModelInfo.model;
             switch (currentModelInfo.type) {
                 case 'session':
-                    return `**Current (this thread):** \`${currentModelInfo.model}\``;
+                    return `**Current (this thread):** \`${displayed}\``;
                 case 'agent':
-                    return `**Current (agent "${currentModelInfo.agentName}"):** \`${currentModelInfo.model}\``;
+                    return `**Current (agent "${currentModelInfo.agentName}"):** \`${displayed}\``;
                 case 'channel':
-                    return `**Current (channel override):** \`${currentModelInfo.model}\``;
+                    return `**Current (channel override):** \`${displayed}\``;
                 case 'global':
-                    return `**Current (global default):** \`${currentModelInfo.model}\``;
+                    return `**Current (global default):** \`${displayed}\``;
                 case 'opencode-config':
                 case 'opencode-recent':
                 case 'opencode-provider-default':
-                    return `**Current (opencode default):** \`${currentModelInfo.model}\``;
-                case 'none':
-                    return '**Current:** none';
+                    return `**Current (opencode default):** \`${displayed}\``;
             }
         })();
         const variantText = (() => {

package/dist/commands/multioauth.js

@@ -1,3 +1,4 @@
+// LEGACY rotation, superseded by @subrouter/opencode. See oauth-rotation-shared.ts.
 /**
  * CLI commands for multi-provider OAuth account management.
  * Mounted via goke .use() in cli.ts under the `multioauth` namespace.