kimaki 0.17.1 → 0.19.0

package/dist/bin.js

@@ -69,8 +69,11 @@ else {
                 return;
             }
             const reason = signal ? `signal ${signal}` : `code ${code}`;
-            console.error(`[kimaki] Process exited with ${reason}, restarting in ${RESTART_DELAY_MS / 1000}s...`);
-            setTimeout(start, RESTART_DELAY_MS);
+            // Progressive backoff: 2s, 4s, 8s, 16s, capped at 30s.
+            // Prevents hammering DNS/gateway during sustained network outages.
+            const delay = Math.min(RESTART_DELAY_MS * 2 ** (restartTimestamps.length - 1), 30_000);
+            console.error(`[kimaki] Process exited with ${reason}, restarting in ${(delay / 1000).toFixed(0)}s...`);
+            setTimeout(start, delay);
         });
     }
     // Forward signals to child so graceful shutdown and heap snapshots work.

package/dist/cache-drift-plugin.js

@@ -0,0 +1,176 @@
+// OpenCode plugin that detects system prompt drift across turns.
+// When the system prompt changes between user messages, it logs a warning
+// with addition/deletion line counts so you know context cache was discarded.
+// This helps spot plugins that mutate the system prompt unexpectedly.
+import { diffLines } from 'diff';
+import * as errore from 'errore';
+import { createPluginLogger, formatPluginErrorWithStack, setPluginLogFilePath } from './plugin-logger.js';
+import { initSentry, notifyError } from './sentry.js';
+const logger = createPluginLogger('OPENCODE');
+function normalizeSystemPrompt({ system }) {
+    return system.join('\n');
+}
+function buildTurnContext({ input, directory, }) {
+    const model = input.model
+        ? `${input.model.providerID}/${input.model.modelID}${input.variant ? `:${input.variant}` : ''}`
+        : undefined;
+    return {
+        agent: input.agent,
+        model,
+        directory,
+    };
+}
+function shouldSuppressDriftWarning({ previousContext, currentContext, }) {
+    if (!previousContext || !currentContext)
+        return false;
+    return (previousContext.agent !== currentContext.agent
+        || previousContext.model !== currentContext.model
+        || previousContext.directory !== currentContext.directory);
+}
+function countDiffLines({ beforeText, afterText, }) {
+    const changes = diffLines(beforeText, afterText);
+    let additions = 0;
+    let deletions = 0;
+    for (const change of changes) {
+        if (change.added)
+            additions += change.count ?? 0;
+        if (change.removed)
+            deletions += change.count ?? 0;
+    }
+    return { additions, deletions };
+}
+function getOrCreateSessionState({ sessions, sessionId, }) {
+    const existing = sessions.get(sessionId);
+    if (existing)
+        return existing;
+    const state = {
+        userTurnCount: 0,
+        previousTurnPrompt: undefined,
+        latestTurnPrompt: undefined,
+        latestTurnPromptTurn: 0,
+        comparedTurn: 0,
+        previousTurnContext: undefined,
+        currentTurnContext: undefined,
+        pendingCompareTimeout: undefined,
+    };
+    sessions.set(sessionId, state);
+    return state;
+}
+function handleSystemTransform({ input, output, sessions, }) {
+    const sessionId = input.sessionID;
+    if (!sessionId)
+        return;
+    const currentPrompt = normalizeSystemPrompt({ system: output.system });
+    const state = getOrCreateSessionState({ sessions, sessionId });
+    const currentTurn = state.userTurnCount;
+    state.latestTurnPrompt = currentPrompt;
+    state.latestTurnPromptTurn = currentTurn;
+    if (currentTurn <= 1)
+        return;
+    if (state.comparedTurn === currentTurn)
+        return;
+    const previousPrompt = state.previousTurnPrompt;
+    state.comparedTurn = currentTurn;
+    if (!previousPrompt || previousPrompt === currentPrompt)
+        return;
+    if (shouldSuppressDriftWarning({
+        previousContext: state.previousTurnContext,
+        currentContext: state.currentTurnContext,
+    })) {
+        return;
+    }
+    const { additions, deletions } = countDiffLines({
+        beforeText: previousPrompt,
+        afterText: currentPrompt,
+    });
+    logger.warn(`[cache-drift] context cache discarded for session ${sessionId}: `
+        + `system prompt changed since previous message (+${additions} / -${deletions} lines)`);
+}
+function getDeletedSessionId({ event }) {
+    if (event.type !== 'session.deleted')
+        return undefined;
+    const sessionInfo = event.properties?.info;
+    if (!sessionInfo || typeof sessionInfo !== 'object')
+        return undefined;
+    const id = sessionInfo.id;
+    return typeof id === 'string' ? id : undefined;
+}
+const cacheDriftPlugin = async ({ directory }) => {
+    initSentry();
+    const dataDir = process.env.KIMAKI_DATA_DIR;
+    if (dataDir) {
+        setPluginLogFilePath(dataDir);
+    }
+    const sessions = new Map();
+    return {
+        'chat.message': async (input) => {
+            const sessionId = input.sessionID;
+            if (!sessionId)
+                return;
+            const state = getOrCreateSessionState({ sessions, sessionId });
+            if (state.userTurnCount > 0
+                && state.latestTurnPromptTurn === state.userTurnCount) {
+                state.previousTurnPrompt = state.latestTurnPrompt;
+                state.previousTurnContext = state.currentTurnContext;
+            }
+            state.currentTurnContext = buildTurnContext({ input, directory });
+            state.userTurnCount += 1;
+        },
+        'experimental.chat.system.transform': async (input, output) => {
+            const result = errore.try({
+                try: () => {
+                    const sessionId = input.sessionID;
+                    if (!sessionId)
+                        return;
+                    const state = getOrCreateSessionState({ sessions, sessionId });
+                    if (state.pendingCompareTimeout) {
+                        clearTimeout(state.pendingCompareTimeout);
+                    }
+                    // Delay one tick so other system-transform hooks can finish mutating
+                    // output.system before we snapshot it for drift detection.
+                    state.pendingCompareTimeout = setTimeout(() => {
+                        state.pendingCompareTimeout = undefined;
+                        try {
+                            handleSystemTransform({ input, output, sessions });
+                        }
+                        catch (err) {
+                            logger.warn(`[cache-drift] ${formatPluginErrorWithStack(err)}`);
+                            void notifyError(err, 'cache drift plugin transform hook failed');
+                        }
+                    }, 0);
+                },
+                catch: (error) => {
+                    return new Error('cache drift transform hook failed', { cause: error });
+                },
+            });
+            if (result instanceof Error) {
+                logger.warn(`[cache-drift] ${formatPluginErrorWithStack(result)}`);
+                void notifyError(result, 'cache drift plugin transform hook failed');
+            }
+        },
+        event: async ({ event }) => {
+            const result = errore.try({
+                try: () => {
+                    if (event.type !== 'session.deleted')
+                        return;
+                    const deletedSessionId = getDeletedSessionId({ event });
+                    if (!deletedSessionId)
+                        return;
+                    const state = sessions.get(deletedSessionId);
+                    if (state?.pendingCompareTimeout) {
+                        clearTimeout(state.pendingCompareTimeout);
+                    }
+                    sessions.delete(deletedSessionId);
+                },
+                catch: (error) => {
+                    return new Error('cache drift event hook failed', { cause: error });
+                },
+            });
+            if (result instanceof Error) {
+                logger.warn(`[cache-drift] ${formatPluginErrorWithStack(result)}`);
+                void notifyError(result, 'cache drift plugin event hook failed');
+            }
+        },
+    };
+};
+export { cacheDriftPlugin };

package/dist/cli-commands/bot.js

@@ -185,6 +185,32 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
 });
+cli
+    .command('bot token', 'Print the bot token for use in CI and automation (KIMAKI_BOT_TOKEN)')
+    .option('--data-dir <path>', 'Data directory for config and database (default: ~/.kimaki)')
+    .action(async (options) => {
+    try {
+        if (options.dataDir) {
+            setDataDir(options.dataDir);
+        }
+        initLogFile(getDataDir());
+        await initDatabase();
+        const botRow = await getBotTokenWithMode();
+        if (!botRow) {
+            cliLogger.error('No bot configured. Run `kimaki` first.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        // Print the token to stdout so it can be captured by scripts.
+        // Use process.stdout.write to avoid extra newline from console.log
+        // when piping to other commands.
+        process.stdout.write(botRow.token + '\n');
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.stack : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
 cli
     .command('bot status clear', 'Clear the bot presence/status')
     .option('--data-dir <path>', 'Data directory for config and database (default: ~/.kimaki)')

package/dist/cli-commands/send.js

@@ -1,4 +1,8 @@
 // Terminal send command for creating Discord threads and scheduling prompts.
+// Designed to work in CI/headless environments with just KIMAKI_BOT_TOKEN.
+// The local SQLite database (channel_directories) is NOT required for the basic
+// flow: post message → create thread → remote bot picks it up. The local project
+// directory mapping is only needed for --send-at, --wait, and --cwd.
 import { goke } from 'goke';
 import { z } from 'zod';
 import { note } from '@clack/prompts';
@@ -271,9 +275,18 @@ cli
             if (!threadData.parent_id) {
                 throw new Error(`Thread has no parent channel: ${targetThreadId}`);
             }
+            // channelConfig is optional: in CI/headless environments the local DB
+            // has no channel_directories rows because the bot hasn't synced yet.
+            // The running bot on the other end resolves the directory from its own DB.
+            // We only require it for features that genuinely need a local directory
+            // (scheduled tasks and --wait).
             const channelConfig = await getChannelDirectory(threadData.parent_id);
-            if (!channelConfig) {
-                throw new Error('Thread parent channel is not configured with a project directory');
+            // Guard early: fail before sending the message if a feature that
+            // needs local project directory mapping is requested.
+            if (!channelConfig && (parsedSchedule || options.wait)) {
+                const flag = parsedSchedule ? '--send-at' : '--wait';
+                throw new Error('Thread parent channel is not configured with a project directory. ' +
+                    `${flag} requires a local project mapping. Run the bot first to sync channel data.`);
             }
             if (parsedSchedule) {
                 const payload = {
@@ -298,6 +311,7 @@ cli
                     channelId: threadData.parent_id,
                     threadId: targetThreadId,
                     sessionId: sessionId || undefined,
+                    // channelConfig is guaranteed: early guard threw if missing with --send-at
                     projectDirectory: channelConfig.directory,
                 });
                 const threadUrl = `https://discord.com/channels/${threadData.guild_id}/${threadData.id}`;
@@ -337,6 +351,8 @@ cli
                 process.stdout.write(`Session: ${existingSessionId}\n`);
             process.stdout.write(`${threadUrl}\n`);
             if (options.wait) {
+                // channelConfig is guaranteed here: early guard above already
+                // threw if channelConfig is missing when --wait is used.
                 const { waitAndOutputSession } = await import('../wait-session.js');
                 await waitAndOutputSession({
                     threadId: targetThreadId,
@@ -352,17 +368,25 @@ cli
         }
         // Get channel info to extract directory from topic
         const channelData = (await rest.get(Routes.channel(channelId)));
+        // channelConfig is optional: in CI/headless environments the local DB
+        // has no channel_directories rows because the bot hasn't synced yet.
+        // The running bot on the other end resolves the directory from its own DB.
+        // We only require it for features that genuinely need a local directory
+        // (--send-at, --wait, --cwd).
         const channelConfig = await getChannelDirectory(channelData.id);
-        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;
+        // Features that require a local project directory mapping
+        const needsProjectDirectory = Boolean(parsedSchedule || options.wait || options.cwd);
+        if (!channelConfig && needsProjectDirectory) {
+            throw new Error(`Channel #${channelData.name} is not configured with a project directory. ` +
+                `${parsedSchedule ? '--send-at' : options.wait ? '--wait' : '--cwd'} requires a local project mapping. ` +
+                'Run the bot first to sync channel data.');
+        }
         // 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.
+            // projectDirectory is guaranteed here: needsProjectDirectory check above
+            // already threw if channelConfig is missing when --cwd is used.
             const cwdResult = await resolveSessionWorkingDirectory({
                 projectDirectory: projectDirectory,
                 candidatePath: options.cwd,
@@ -510,8 +534,8 @@ cli
             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.
+            // projectDirectory is guaranteed here: needsProjectDirectory check above
+            // already threw if channelConfig is missing when --wait is used.
             const { waitAndOutputSession } = await import('../wait-session.js');
             await waitAndOutputSession({
                 threadId: threadData.id,

package/dist/cli-commands/session.js

@@ -11,7 +11,7 @@ import { fileURLToPath } from 'node:url';
 import { spawn, execSync } from 'node:child_process';
 import { createLogger, LogPrefix, initLogFile } from '../logger.js';
 import { createDiscordClient, initDatabase, getChannelDirectory, initializeOpencodeForDirectory, createProjectChannels } from '../discord-bot.js';
-import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory, getThreadWorktree } from '../database.js';
+import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory, getThreadWorktreeOrWorkspace } from '../database.js';
 import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';
@@ -29,9 +29,9 @@ const cli = goke();
 async function resolveSessionDirectoryFromDatabase({ sessionId, }) {
     const threadId = await getThreadIdBySessionId(sessionId);
     if (threadId) {
-        const worktree = await getThreadWorktree(threadId);
-        if (worktree?.status === 'ready' && worktree.worktree_directory) {
-            return worktree.worktree_directory;
+        const workspace = await getThreadWorktreeOrWorkspace(threadId);
+        if (workspace?.status === 'ready' && workspace.workspace_directory) {
+            return workspace.workspace_directory;
         }
         const { token: botToken } = await resolveBotCredentials({});
         const rest = createDiscordRest(botToken);
@@ -126,6 +126,7 @@ cli
 cli
     .command('session read <sessionId>', 'Read a session conversation as markdown (pipe to file to grep)')
     .option('--project <path>', 'Project directory (defaults to cwd)')
+    .option('--verbose', 'Show full tool inputs and outputs instead of compact summaries')
     .action(async (sessionId, options) => {
     try {
         const projectDirectory = path.resolve(options.project || '.');
@@ -137,8 +138,9 @@ cli
             process.exit(EXIT_NO_RESTART);
         }
         // Try current project first (fast path)
+        const compactTools = !options.verbose;
         const markdown = new ShareMarkdown(getClient());
-        const result = await markdown.generate({ sessionID: sessionId });
+        const result = await markdown.generate({ sessionID: sessionId, compactTools });
         if (!(result instanceof Error)) {
             process.stdout.write(result);
             process.exit(0);
@@ -171,6 +173,7 @@ cli
             const otherMarkdown = new ShareMarkdown(otherClient());
             const otherResult = await otherMarkdown.generate({
                 sessionID: sessionId,
+                compactTools,
             });
             if (!(otherResult instanceof Error)) {
                 process.stdout.write(otherResult);

package/dist/cli-runner.js

@@ -37,6 +37,27 @@ export const KIMAKI_GATEWAY_PROXY_URL = process.env.KIMAKI_GATEWAY_PROXY_URL ||
 export const KIMAKI_GATEWAY_PROXY_REST_BASE_URL = getGatewayProxyRestBaseUrl({
     gatewayUrl: KIMAKI_GATEWAY_PROXY_URL,
 });
+export function getOpenUrlCommand(url, platform = process.platform) {
+    if (platform === 'darwin') {
+        return { command: 'open', args: [url] };
+    }
+    if (platform === 'win32') {
+        return { command: 'rundll32.exe', args: ['url.dll,FileProtocolHandler', url] };
+    }
+    return { command: 'xdg-open', args: [url] };
+}
+function openUrlInDefaultBrowser(url) {
+    const { command, args } = getOpenUrlCommand(url);
+    const child = spawn(command, args, {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+    });
+    child.on('error', (error) => {
+        cliLogger.warn('Failed to open install URL:', error instanceof Error ? error.message : String(error));
+    });
+    child.unref();
+}
 // Strip bracketed paste escape sequences from terminal input.
 // iTerm2 and other terminals wrap pasted content with \x1b[200~ and \x1b[201~
 // which can cause validation to fail on macOS. See: https://github.com/remorses/kimaki/issues/18
@@ -79,11 +100,23 @@ export function appIdFromToken(token) {
 // but don't run the interactive wizard.
 // In gateway mode, also sets store.discordBaseUrl so REST calls
 // are routed through the gateway-proxy REST endpoint.
+//
+// Priority: KIMAKI_BOT_TOKEN env var takes precedence over saved DB
+// credentials. This lets CI and cross-instance commands override the
+// local bot identity. If the env token looks like a gateway credential
+// (clientId:clientSecret), the gateway proxy REST URL is set automatically.
 export async function resolveBotCredentials({ appIdOverride } = {}) {
-    // DB first: getBotTokenWithMode() sets store.discordBaseUrl which is
-    // required in gateway mode so REST calls route through the proxy.
-    // Without this, inherited KIMAKI_BOT_TOKEN (a gateway credential like
-    // clientId:clientSecret) would be sent directly to discord.com → 401.
+    const envToken = process.env.KIMAKI_BOT_TOKEN;
+    if (envToken) {
+        const isGatewayToken = envToken.includes(':');
+        if (isGatewayToken) {
+            // Gateway tokens need REST calls routed through the proxy, not discord.com
+            store.setState({ discordBaseUrl: KIMAKI_GATEWAY_PROXY_REST_BASE_URL });
+        }
+        const appId = appIdOverride || appIdFromToken(envToken);
+        return { token: envToken, appId };
+    }
+    // Fall back to saved credentials in the database
     const botRow = await getBotTokenWithMode().catch((e) => {
         cliLogger.error('Database error:', e instanceof Error ? e.message : String(e));
         return null;
@@ -91,12 +124,6 @@ export async function resolveBotCredentials({ appIdOverride } = {}) {
     if (botRow) {
         return { token: botRow.token, appId: appIdOverride || botRow.appId };
     }
-    // Fall back to env var for CI/headless deployments with no database
-    const envToken = process.env.KIMAKI_BOT_TOKEN;
-    if (envToken) {
-        const appId = appIdOverride || appIdFromToken(envToken);
-        return { token: envToken, appId };
-    }
     cliLogger.error('No bot token found. Set KIMAKI_BOT_TOKEN env var or run `kimaki` first to set up.');
     process.exit(EXIT_NO_RESTART);
 }
@@ -281,6 +308,28 @@ function readErrorField(error, key) {
     }
     return undefined;
 }
+/** Transient network errors that may resolve on retry (DNS down, gateway unreachable). */
+const TRANSIENT_ERROR_CODES = new Set([
+    'ENOTFOUND',
+    'ECONNREFUSED',
+    'ETIMEDOUT',
+    'ECONNRESET',
+    'EAI_AGAIN',
+    'EPIPE',
+    'EHOSTUNREACH',
+    'ENETUNREACH',
+]);
+export function isTransientNetworkError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const code = error.code;
+    if (code && TRANSIENT_ERROR_CODES.has(code))
+        return true;
+    // discord.js wraps errors in cause chains
+    if (error.cause instanceof Error)
+        return isTransientNetworkError(error.cause);
+    return false;
+}
 export function isDiscordMemberLookupUnavailable(error) {
     const status = readErrorField(error, 'status');
     if (status === 403) {
@@ -827,13 +876,7 @@ export async function resolveCredentials({ forceRestartOnboarding, forceGateway,
         if (isInteractive) {
             note(`Open this URL to install the Kimaki bot in your Discord server:\n\n${oauthUrl}\n\nDo not share this URL with anyone — it contains your credentials.\n\nIf you don't have a server, create one first (+ button in the Discord sidebar).`, 'Install Bot');
             // Open URL in default browser
-            const { exec } = await import('node:child_process');
-            const openCmd = process.platform === 'darwin'
-                ? 'open'
-                : process.platform === 'win32'
-                    ? 'start'
-                    : 'xdg-open';
-            exec(`${openCmd} "${oauthUrl}"`);
+            openUrlInDefaultBrowser(oauthUrl);
         }
         else {
             // Non-TTY: emit structured JSON so the host process can show the URL to the user.
@@ -1011,7 +1054,9 @@ export async function run({ restartOnboarding, addChannels, useWorktrees, enable
             possiblePathsWindows: ['~\\.bun\\bin\\bun.exe'],
         }),
     ]);
-    void backgroundUpgradeKimaki();
+    if (store.getState().autoUpgradeEnabled) {
+        void backgroundUpgradeKimaki();
+    }
     // Start in-process Hrana server before database init. Required for the bot
     // process because it serves as both the DB server and the single-instance
     // lock (binds the fixed lock port). Without it, IPC and lock enforcement
@@ -1152,6 +1197,13 @@ export async function run({ restartOnboarding, addChannels, useWorktrees, enable
     catch (error) {
         cliLogger.log('Failed to connect to Discord', discordClient.ws.gateway);
         cliLogger.error('Error: ' + (error instanceof Error ? error.stack : String(error)));
+        // Transient network errors (DNS down, gateway unreachable) should allow
+        // the bin.ts wrapper to restart us after a delay. Only truly fatal errors
+        // (bad token, invalid intent, etc.) should use EXIT_NO_RESTART.
+        if (isTransientNetworkError(error)) {
+            cliLogger.error('Transient network error, exiting for wrapper restart...');
+            process.exit(1);
+        }
         process.exit(EXIT_NO_RESTART);
     }
     await setBotToken(appId, token);

package/dist/cli-runner.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, test } from 'vitest';
+import { getOpenUrlCommand } from './cli-runner.js';
+describe('getOpenUrlCommand', () => {
+    const installUrl = 'https://kimaki.dev/discord-install?clientId=abc&clientSecret=def';
+    test('uses a shell-free opener on Windows', () => {
+        expect(getOpenUrlCommand(installUrl, 'win32')).toEqual({
+            command: 'rundll32.exe',
+            args: ['url.dll,FileProtocolHandler', installUrl],
+        });
+    });
+    test('uses open on macOS', () => {
+        expect(getOpenUrlCommand(installUrl, 'darwin')).toEqual({
+            command: 'open',
+            args: [installUrl],
+        });
+    });
+    test('uses xdg-open on Linux', () => {
+        expect(getOpenUrlCommand(installUrl, 'linux')).toEqual({
+            command: 'xdg-open',
+            args: [installUrl],
+        });
+    });
+});

package/dist/cli.js

@@ -43,6 +43,7 @@ cli
     .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('--no-auto-upgrade', 'Disable background auto-upgrade on startup')
     .option('--gateway', 'Force gateway mode (use the gateway Kimaki bot instead of a self-hosted bot)')
     .option('--gateway-callback-url <url>', 'After gateway OAuth install, redirect to this URL instead of the default success page (appends ?guild_id=<id>)')
     .option('--allow-mention <type>', z
@@ -156,6 +157,7 @@ cli
             ...(options.noCritique && { critiqueEnabled: false }),
             ...(options.allowAllUsers && { allowAllUsers: true }),
             ...(permissionTimeoutMs !== undefined && { permissionTimeoutMs }),
+            ...(options.noAutoUpgrade && { autoUpgradeEnabled: false }),
             ...(options.disableSync && { syncEnabled: false }),
             ...(enabledSkills.length > 0 && { enabledSkills }),
             ...(disabledSkills.length > 0 && { disabledSkills }),
@@ -182,6 +184,9 @@ cli
         if (options.noCritique) {
             cliLogger.log('Critique disabled: diffs will not be auto-uploaded to critique.work');
         }
+        if (options.noAutoUpgrade) {
+            cliLogger.log('Auto-upgrade disabled: kimaki will not check for updates on startup');
+        }
         if (options.disableSync) {
             cliLogger.log('Background sync disabled: external OpenCode sessions will not appear in Discord');
         }

package/dist/commands/ask-question.js

@@ -11,6 +11,14 @@ const logger = createLogger(LogPrefix.ASK_QUESTION);
 // TTL prevents unbounded growth if user never answers a question.
 const QUESTION_CONTEXT_TTL_MS = 10 * 60 * 1000;
 export const pendingQuestionContexts = new Map();
+export function areAllQuestionsAnswered({ totalQuestions, answers, }) {
+    for (let i = 0; i < totalQuestions; i++) {
+        if (!answers[i]) {
+            return false;
+        }
+    }
+    return true;
+}
 export function findPendingQuestionContextForRequest({ threadId, requestId, }) {
     for (const [contextHash, context] of pendingQuestionContexts) {
         if (context.thread.id !== threadId) {
@@ -64,7 +72,6 @@ export async function showAskUserQuestionDropdowns({ thread, sessionId, director
         questions: input.questions,
         answers: {},
         totalQuestions: input.questions.length,
-        answeredCount: 0,
         contextHash,
     };
     pendingQuestionContexts.set(contextHash, context);
@@ -163,6 +170,10 @@ export async function handleAskQuestionSelectMenu(interaction) {
         logger.error(`Question index ${questionIndex} not found in context`);
         return;
     }
+    if (context.answers[questionIndex]) {
+        logger.log(`Ignored duplicate answer for question ${context.requestId} index ${questionIndex}`);
+        return;
+    }
     // Check if "other" was selected
     if (selectedValues.includes('other')) {
         // User wants to provide custom answer
@@ -176,7 +187,6 @@ export async function handleAskQuestionSelectMenu(interaction) {
             return question.options[optIdx]?.label || `Option ${optIdx + 1}`;
         });
     }
-    context.answeredCount++;
     // Update this question's message: show answer and remove dropdown
     const answeredText = context.answers[questionIndex].join(', ');
     await interaction.editReply({
@@ -186,7 +196,7 @@ export async function handleAskQuestionSelectMenu(interaction) {
     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) {
+    if (areAllQuestionsAnswered(context)) {
         // All questions answered - send result back to session
         await submitQuestionAnswers(context);
         deletePendingQuestionContextsForRequest({

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

@@ -1,6 +1,6 @@
 // Tests AskUserQuestion request deduplication and cleanup helpers.
 import { afterEach, describe, expect, test, vi } from 'vitest';
-import { deletePendingQuestionContextsForRequest, pendingQuestionContexts, showAskUserQuestionDropdowns, } from './ask-question.js';
+import { areAllQuestionsAnswered, deletePendingQuestionContextsForRequest, pendingQuestionContexts, showAskUserQuestionDropdowns, } from './ask-question.js';
 function createFakeThread() {
     const send = vi.fn(async () => {
         return { id: 'msg-1' };
@@ -69,7 +69,6 @@ describe('ask-question', () => {
                 }],
             answers: {},
             totalQuestions: 1,
-            answeredCount: 0,
             contextHash: 'ctx-1',
         };
         pendingQuestionContexts.set('ctx-1', baseContext);
@@ -89,4 +88,21 @@ describe('ask-question', () => {
         expect(removed).toBe(2);
         expect([...pendingQuestionContexts.keys()]).toEqual(['ctx-3']);
     });
+    test('requires every question to have an answer', () => {
+        expect(areAllQuestionsAnswered({
+            totalQuestions: 3,
+            answers: {
+                0: ['Alpha'],
+                2: ['Gamma'],
+            },
+        })).toBe(false);
+        expect(areAllQuestionsAnswered({
+            totalQuestions: 3,
+            answers: {
+                0: ['Alpha'],
+                1: ['Beta'],
+                2: ['Gamma'],
+            },
+        })).toBe(true);
+    });
 });