kimaki 0.4.78 → 0.4.80

package/dist/queue-drain-after-interactive-ui.e2e.test.js

@@ -0,0 +1,119 @@
+// E2e test: queued messages must drain immediately when the session is idle,
+// even if action buttons are still pending. The isSessionBusy check is
+// sufficient — hasPendingInteractiveUi() should NOT block queue drain.
+import { describe, test, expect } from 'vitest';
+import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
+import { waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
+import { getThreadSession } from './database.js';
+import { pendingActionButtonContexts, showActionButtons, } from './commands/action-buttons.js';
+const TEXT_CHANNEL_ID = '200000000000001020';
+describe('queue drain with pending interactive UI', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-drain-interactive-ui',
+        dirName: 'qa-drain-interactive-ui',
+        username: 'drain-ui-tester',
+    });
+    test('queued message drains immediately while action buttons are still pending', async () => {
+        // 1. Create a thread with a first completed reply
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: drain-button-setup',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: drain-button-setup';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'ok',
+            timeout: 4_000,
+        });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: ctx.discord.botUserId,
+        });
+        // 2. Show action buttons (session is idle, buttons are pending)
+        const currentSessionId = await getThreadSession(thread.id);
+        if (!currentSessionId) {
+            throw new Error('Expected thread session id');
+        }
+        const channel = await ctx.botClient.channels.fetch(thread.id);
+        if (!channel || !channel.isThread()) {
+            throw new Error('Expected Discord thread channel');
+        }
+        await showActionButtons({
+            thread: channel,
+            sessionId: currentSessionId,
+            directory: ctx.directories.projectDirectory,
+            buttons: [{ label: 'Pending button', color: 'white' }],
+        });
+        // Verify buttons are pending
+        const start = Date.now();
+        while (Date.now() - start < 4_000) {
+            const entry = [...pendingActionButtonContexts.entries()].find(([, context]) => {
+                return context.thread.id === thread.id && Boolean(context.messageId);
+            });
+            if (entry) {
+                break;
+            }
+            await new Promise((resolve) => {
+                setTimeout(resolve, 100);
+            });
+        }
+        expect([...pendingActionButtonContexts.values()].some((c) => {
+            return c.thread.id === thread.id;
+        })).toBe(true);
+        // 3. Queue a message via /queue while buttons are still pending.
+        //    The queue should drain immediately because session is idle.
+        //    Currently FAILS: hasPendingInteractiveUi() blocks tryDrainQueue().
+        const { id: queueInteractionId } = await th.user(TEST_USER_ID)
+            .runSlashCommand({
+            name: 'queue',
+            options: [{ name: 'message', type: 3, value: 'Reply with exactly: post-button-drain' }],
+        });
+        const queueAck = await th.waitForInteractionAck({
+            interactionId: queueInteractionId,
+            timeout: 4_000,
+        });
+        if (!queueAck.messageId) {
+            throw new Error('Expected /queue response message id');
+        }
+        // 4. Queued message should dispatch immediately (not stay "Queued").
+        //    The dispatch indicator should appear quickly.
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: '» **drain-ui-tester:** Reply with exactly: post-button-drain',
+            timeout: 4_000,
+        });
+        // 5. Wait for the footer after the drained message completes
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: '» **drain-ui-tester:**',
+            afterAuthorId: ctx.discord.botUserId,
+        });
+        const timeline = await th.text({ showInteractions: true });
+        expect(timeline).toMatchInlineSnapshot(`
+        "--- from: user (drain-ui-tester)
+        Reply with exactly: drain-button-setup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        **Action Required**
+        [user interaction]
+        » **drain-ui-tester:** Reply with exactly: post-button-drain
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `);
+    }, 20_000);
+});

package/dist/session-handler/thread-session-runtime.js

@@ -10,7 +10,7 @@ import path from 'node:path';
 import prettyMilliseconds from 'pretty-ms';
 import * as errore from 'errore';
 import * as threadState from './thread-runtime-state.js';
-import { getOpencodeClient, initializeOpencodeForDirectory, buildSessionPermissions, subscribeOpencodeServerLifecycle, } from '../opencode.js';
+import { getOpencodeClient, initializeOpencodeForDirectory, buildSessionPermissions, parsePermissionRules, subscribeOpencodeServerLifecycle, } from '../opencode.js';
 import { isAbortError } from '../utils.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { sendThreadMessage, SILENT_MESSAGE_FLAGS, NOTIFY_MESSAGE_FLAGS, } from '../discord-utils.js';
@@ -580,12 +580,16 @@ export class ThreadSessionRuntime {
         }
         const compacted = structuredClone(event);
         if (compacted.type === 'message.updated') {
-            if (compacted.properties.info.role !== 'user') {
-                return compacted;
-            }
-            delete compacted.properties.info.system;
-            delete compacted.properties.info.summary;
-            delete compacted.properties.info.tools;
+            // Strip heavy fields from ALL roles. Derivation only needs lightweight
+            // metadata (id, role, sessionID, parentID, time, finish, error, modelID,
+            // providerID, mode, tokens). The parts array on assistant messages grows
+            // with every tool call and was the primary OOM vector — 1000 buffer entries
+            // each carrying the full cumulative parts array reached 4GB+.
+            const info = compacted.properties.info;
+            delete info.system;
+            delete info.summary;
+            delete info.tools;
+            delete info.parts;
             return compacted;
         }
         const part = compacted.properties.part;
@@ -787,8 +791,16 @@ export class ThreadSessionRuntime {
     // Global events (tui.toast.show) bypass the guard.
     // Subtask sessions also bypass — they're tracked in subtaskSessions.
     async handleEvent(event) {
-        // Push into bounded event buffer for waitForEvent() consumers.
-        this.appendEventToBuffer(event);
+        // Skip message.part.delta from the event buffer — no derivation function
+        // (isSessionBusy, doesLatestUserTurnHaveNaturalCompletion, waitForEvent,
+        // etc.) uses them. During long streaming responses they flood the 1000-slot
+        // buffer, evicting session.status busy events that isSessionBusy needs,
+        // causing tryDrainQueue to drain the local queue while the session is
+        // actually still busy. This was the root cause of "? queue" messages
+        // interrupting instead of queuing.
+        if (event.type !== 'message.part.delta') {
+            this.appendEventToBuffer(event);
+        }
         const sessionId = this.state?.sessionId;
         const eventSessionId = getOpencodeEventSessionId(event);
         if (shouldLogSessionEvents) {
@@ -1377,7 +1389,7 @@ export class ThreadSessionRuntime {
                     });
                     if (showResult instanceof Error) {
                         logger.error('[ACTION] Failed to show action buttons:', showResult);
-                        await sendThreadMessage(this.thread, `Failed to show action buttons: ${showResult.message}`);
+                        await sendThreadMessage(this.thread, `Failed to show action buttons: ${showResult.message}`, { flags: NOTIFY_MESSAGE_FLAGS });
                     }
                 },
             });
@@ -1579,7 +1591,7 @@ export class ThreadSessionRuntime {
         }
         const errorMessage = formatSessionErrorFromProps(properties.error);
         logger.error(`Sending error to thread: ${errorMessage}`);
-        await sendThreadMessage(this.thread, `✗ opencode session error: ${errorMessage}`);
+        await sendThreadMessage(this.thread, `✗ opencode session error: ${errorMessage}`, { flags: NOTIFY_MESSAGE_FLAGS });
         await this.persistEventBufferDebounced.flush();
         // Inject synthetic idle so isSessionBusy() returns false and queued
         // messages can drain. Without this, a session error leaves the event
@@ -1803,13 +1815,16 @@ export class ThreadSessionRuntime {
             // Helper: stop typing and drain queued local messages on error.
             const cleanupOnError = async (errorMessage) => {
                 this.stopTyping();
-                await sendThreadMessage(this.thread, errorMessage);
+                await sendThreadMessage(this.thread, errorMessage, {
+                    flags: NOTIFY_MESSAGE_FLAGS,
+                });
                 await this.tryDrainQueue({ showIndicator: true });
             };
             // ── Ensure session ──────────────────────────────────────
             const sessionResult = await this.ensureSession({
                 prompt: input.prompt,
                 agent: input.agent,
+                permissions: input.permissions,
                 sessionStartScheduleKind: input.sessionStartSource?.scheduleKind,
                 sessionStartScheduledTaskId: input.sessionStartSource?.scheduledTaskId,
             });
@@ -2039,6 +2054,7 @@ export class ThreadSessionRuntime {
             command: input.command,
             agent: input.agent,
             model: input.model,
+            permissions: input.permissions,
             sessionStartScheduleKind: input.sessionStartSource?.scheduleKind,
             sessionStartScheduledTaskId: input.sessionStartSource?.scheduledTaskId,
         };
@@ -2051,7 +2067,6 @@ export class ThreadSessionRuntime {
             const position = stateAfterEnqueue?.queueItems.length ?? 0;
             const willDrainNow = stateAfterEnqueue
                 ? (stateAfterEnqueue.queueItems.length > 0
-                    && !this.hasPendingInteractiveUi()
                     && !this.isMainSessionBusy())
                 : false;
             result = !willDrainNow && position > 0
@@ -2127,6 +2142,13 @@ export class ThreadSessionRuntime {
                     mode: result.mode,
                     preprocess: undefined,
                 };
+                const hasPromptText = resolvedInput.prompt.trim().length > 0;
+                const hasImages = (resolvedInput.images?.length || 0) > 0;
+                if (!hasPromptText && !hasImages && !resolvedInput.command) {
+                    logger.warn(`[INGRESS] Skipping empty preprocessed input threadId=${this.threadId}`);
+                    resolveOuter({ queued: false });
+                    return;
+                }
                 // Route with the resolved mode through normal paths.
                 // Await the enqueue so session state (ensureSession, setThreadSession)
                 // is persisted before the next message's preprocessing reads it.
@@ -2228,9 +2250,11 @@ export class ThreadSessionRuntime {
         if (thread.queueItems.length === 0) {
             return;
         }
-        if (this.hasPendingInteractiveUi()) {
-            return;
-        }
+        // Interactive UI (action buttons, questions, permissions) does NOT block
+        // queue drain. The isSessionBusy check is sufficient: questions and
+        // permissions keep the OpenCode session busy, so drain is naturally
+        // blocked. Action buttons are fire-and-forget (session already idle),
+        // so queued messages should dispatch immediately.
         const sessionBusy = thread.sessionId
             ? isSessionBusy({ events: this.eventBuffer, sessionId: thread.sessionId })
             : false;
@@ -2284,12 +2308,13 @@ export class ThreadSessionRuntime {
         const sessionResult = await this.ensureSession({
             prompt: input.prompt,
             agent: input.agent,
+            permissions: input.permissions,
             sessionStartScheduleKind: input.sessionStartScheduleKind,
             sessionStartScheduledTaskId: input.sessionStartScheduledTaskId,
         });
         if (sessionResult instanceof Error) {
             this.stopTyping();
-            await sendThreadMessage(this.thread, `✗ ${sessionResult.message}`);
+            await sendThreadMessage(this.thread, `✗ ${sessionResult.message}`, { flags: NOTIFY_MESSAGE_FLAGS });
             // Show indicator: this dispatch failed, so the next queued message
             // has been waiting — the user needs to see which one is starting.
             await this.tryDrainQueue({ showIndicator: true });
@@ -2327,7 +2352,7 @@ export class ThreadSessionRuntime {
         });
         if (earlyAgentResult instanceof Error) {
             this.stopTyping();
-            await sendThreadMessage(this.thread, `Failed to resolve agent: ${earlyAgentResult.message}`);
+            await sendThreadMessage(this.thread, `Failed to resolve agent: ${earlyAgentResult.message}`, { flags: NOTIFY_MESSAGE_FLAGS });
             // Show indicator: dispatch failed mid-setup, next queued message was waiting.
             await this.tryDrainQueue({ showIndicator: true });
             return;
@@ -2363,7 +2388,7 @@ export class ThreadSessionRuntime {
         ]);
         if (earlyModelResult instanceof Error) {
             this.stopTyping();
-            await sendThreadMessage(this.thread, `Failed to resolve model: ${earlyModelResult.message}`);
+            await sendThreadMessage(this.thread, `Failed to resolve model: ${earlyModelResult.message}`, { flags: NOTIFY_MESSAGE_FLAGS });
             // Show indicator: dispatch failed mid-setup, next queued message was waiting.
             await this.tryDrainQueue({ showIndicator: true });
             return;
@@ -2496,7 +2521,7 @@ export class ThreadSessionRuntime {
                 if (timedOut) {
                     logger.warn(`[DISPATCH] Command timed out after 30s sessionId=${session.id}`);
                     this.stopTyping();
-                    await sendThreadMessage(this.thread, '✗ Command timed out after 30 seconds. Try a shorter command or run it with /run-shell-command.');
+                    await sendThreadMessage(this.thread, '✗ Command timed out after 30 seconds. Try a shorter command or run it with /run-shell-command.', { flags: NOTIFY_MESSAGE_FLAGS });
                     await this.dispatchAction(() => {
                         return this.tryDrainQueue({ showIndicator: true });
                     });
@@ -2511,7 +2536,7 @@ export class ThreadSessionRuntime {
                 logger.error(`[DISPATCH] Command SDK call failed: ${commandResponse.message}`);
                 void notifyError(commandResponse, 'Failed to send command to OpenCode');
                 this.stopTyping();
-                await sendThreadMessage(this.thread, `✗ Unexpected bot Error: ${commandResponse.message}`);
+                await sendThreadMessage(this.thread, `✗ Unexpected bot Error: ${commandResponse.message}`, { flags: NOTIFY_MESSAGE_FLAGS });
                 await this.dispatchAction(() => {
                     return this.tryDrainQueue({ showIndicator: true });
                 });
@@ -2528,7 +2553,9 @@ export class ThreadSessionRuntime {
                 logger.error(`[DISPATCH] ${apiError.message}`);
                 void notifyError(apiError, 'OpenCode API error during command');
                 this.stopTyping();
-                await sendThreadMessage(this.thread, `✗ ${apiError.message}`);
+                await sendThreadMessage(this.thread, `✗ ${apiError.message}`, {
+                    flags: NOTIFY_MESSAGE_FLAGS,
+                });
                 await this.dispatchAction(() => {
                     return this.tryDrainQueue({ showIndicator: true });
                 });
@@ -2572,7 +2599,9 @@ export class ThreadSessionRuntime {
             logger.error(`[DISPATCH] Prompt API call failed: ${errorMessage}`);
             void notifyError(errorObject, 'OpenCode API error during local queue prompt');
             this.stopTyping();
-            await sendThreadMessage(this.thread, `✗ OpenCode API error: ${errorMessage}`);
+            await sendThreadMessage(this.thread, `✗ OpenCode API error: ${errorMessage}`, {
+                flags: NOTIFY_MESSAGE_FLAGS,
+            });
             await this.dispatchAction(() => {
                 return this.tryDrainQueue({ showIndicator: true });
             });
@@ -2582,7 +2611,7 @@ export class ThreadSessionRuntime {
     }
     // ── Session Ensure ──────────────────────────────────────────
     // Creates or reuses the OpenCode session for this thread.
-    async ensureSession({ prompt, agent, sessionStartScheduleKind, sessionStartScheduledTaskId, }) {
+    async ensureSession({ prompt, agent, permissions, sessionStartScheduleKind, sessionStartScheduledTaskId, }) {
         const directory = this.projectDirectory;
         // Resolve worktree info for server initialization
         const worktreeInfo = await getThreadWorktree(this.thread.id);
@@ -2625,10 +2654,15 @@ export class ThreadSessionRuntime {
             // access its own project directory (and worktree origin if applicable)
             // without prompts. These override the server-level 'ask' default via
             // opencode's findLast() rule evaluation.
-            const sessionPermissions = buildSessionPermissions({
-                directory: this.sdkDirectory,
-                originalRepoDirectory,
-            });
+            // CLI --permission rules are appended after base rules so they win
+            // via opencode's findLast() evaluation.
+            const sessionPermissions = [
+                ...buildSessionPermissions({
+                    directory: this.sdkDirectory,
+                    originalRepoDirectory,
+                }),
+                ...parsePermissionRules(permissions ?? []),
+            ];
             const sessionResponse = await getClient().session.create({
                 title: sessionTitle,
                 directory: this.sdkDirectory,
@@ -2759,7 +2793,12 @@ export class ThreadSessionRuntime {
             : `${folderName} ⋅ `;
         const footerText = `*${projectInfo}${sessionDuration}${contextInfo}${modelInfo}${agentInfo}*`;
         this.stopTyping();
-        await sendThreadMessage(this.thread, footerText, { flags: NOTIFY_MESSAGE_FLAGS });
+        // Skip notification if there's a queued message next — the user only
+        // needs to be notified when the entire queue finishes.
+        const queuedNext = (threadState.getThreadState(this.threadId)?.queueItems.length ?? 0) > 0;
+        await sendThreadMessage(this.thread, footerText, {
+            flags: queuedNext ? SILENT_MESSAGE_FLAGS : NOTIFY_MESSAGE_FLAGS,
+        });
         logger.log(`DURATION: Session completed in ${sessionDuration}, model ${runInfo.model}, tokens ${runInfo.tokensUsed}`);
     }
     /** Reset per-run state for the next prompt dispatch. */

package/dist/startup-time.e2e.test.js

@@ -0,0 +1,295 @@
+// Measures time-to-ready for the kimaki Discord bot startup.
+// Used as a baseline to track startup performance and guide optimizations
+// for scale-to-zero deployments where cold start time is critical.
+//
+// Measures each phase independently:
+//   1. Hrana server start (DB + lock port)
+//   2. Database init (Prisma connect via HTTP)
+//   3. Discord.js client creation + login (Gateway READY)
+//   4. startDiscordBot (event handlers + markDiscordGatewayReady)
+//   5. OpenCode server startup (spawn + health poll)
+//   6. Total wall-clock time from zero to "bot ready"
+//
+// Uses discord-digital-twin so Gateway READY is instant (no real Discord).
+// OpenCode startup uses deterministic provider (no real LLM).
+import fs from 'node:fs';
+import path from 'node:path';
+import url from 'node:url';
+import { describe, test, expect, afterAll } from 'vitest';
+import { ChannelType, Client, GatewayIntentBits, Partials } from 'discord.js';
+import { DigitalDiscord } from 'discord-digital-twin/src';
+import { buildDeterministicOpencodeConfig, } from 'opencode-deterministic-provider';
+import { setDataDir } from './config.js';
+import { startDiscordBot } from './discord-bot.js';
+import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, } from './database.js';
+import { startHranaServer, stopHranaServer } from './hrana-server.js';
+import { initializeOpencodeForDirectory, stopOpencodeServer } from './opencode.js';
+import { chooseLockPort, cleanupTestSessions } from './test-utils.js';
+function createRunDirectories() {
+    const root = path.resolve(process.cwd(), 'tmp', 'startup-time-e2e');
+    fs.mkdirSync(root, { recursive: true });
+    const dataDir = fs.mkdtempSync(path.join(root, 'data-'));
+    const projectDirectory = path.join(root, 'project');
+    fs.mkdirSync(projectDirectory, { recursive: true });
+    return { root, dataDir, projectDirectory };
+}
+function createDiscordJsClient({ restUrl }) {
+    return new Client({
+        intents: [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.GuildMessages,
+            GatewayIntentBits.MessageContent,
+            GatewayIntentBits.GuildVoiceStates,
+        ],
+        partials: [
+            Partials.Channel,
+            Partials.Message,
+            Partials.User,
+            Partials.ThreadMember,
+        ],
+        rest: {
+            api: restUrl,
+            version: '10',
+        },
+    });
+}
+function createMinimalMatchers() {
+    return [
+        {
+            id: 'startup-test-reply',
+            priority: 10,
+            when: {
+                lastMessageRole: 'user',
+                rawPromptIncludes: 'startup-test',
+            },
+            then: {
+                parts: [
+                    { type: 'stream-start', warnings: [] },
+                    { type: 'text-start', id: 'startup-reply' },
+                    { type: 'text-delta', id: 'startup-reply', delta: 'ok' },
+                    { type: 'text-end', id: 'startup-reply' },
+                    {
+                        type: 'finish',
+                        finishReason: 'stop',
+                        usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                    },
+                ],
+            },
+        },
+    ];
+}
+const TEST_USER_ID = '900000000000000777';
+const TEXT_CHANNEL_ID = '900000000000000778';
+describe('startup time measurement', () => {
+    let directories;
+    let discord;
+    let botClient = null;
+    const testStartTime = Date.now();
+    afterAll(async () => {
+        if (directories) {
+            await cleanupTestSessions({
+                projectDirectory: directories.projectDirectory,
+                testStartTime,
+            });
+        }
+        if (botClient) {
+            botClient.destroy();
+        }
+        await Promise.all([
+            stopOpencodeServer().catch(() => { }),
+            closeDatabase().catch(() => { }),
+            stopHranaServer().catch(() => { }),
+            discord?.stop().catch(() => { }),
+        ]);
+        delete process.env['KIMAKI_LOCK_PORT'];
+        delete process.env['KIMAKI_DB_URL'];
+        if (directories) {
+            fs.rmSync(directories.dataDir, { recursive: true, force: true });
+        }
+    });
+    test('measures per-phase startup timings', async () => {
+        directories = createRunDirectories();
+        const lockPort = chooseLockPort({ key: 'startup-time-e2e' });
+        process.env['KIMAKI_LOCK_PORT'] = String(lockPort);
+        setDataDir(directories.dataDir);
+        const digitalDiscordDbPath = path.join(directories.dataDir, 'digital-discord.db');
+        discord = new DigitalDiscord({
+            guild: {
+                name: 'Startup Time Guild',
+                ownerId: TEST_USER_ID,
+            },
+            channels: [
+                {
+                    id: TEXT_CHANNEL_ID,
+                    name: 'startup-time',
+                    type: ChannelType.GuildText,
+                },
+            ],
+            users: [
+                {
+                    id: TEST_USER_ID,
+                    username: 'startup-tester',
+                },
+            ],
+            dbUrl: `file:${digitalDiscordDbPath}`,
+        });
+        await discord.start();
+        // Write deterministic opencode config
+        const providerNpm = url
+            .pathToFileURL(path.resolve(process.cwd(), '..', 'opencode-deterministic-provider', 'src', 'index.ts'))
+            .toString();
+        const opencodeConfig = buildDeterministicOpencodeConfig({
+            providerName: 'deterministic-provider',
+            providerNpm,
+            model: 'deterministic-v2',
+            smallModel: 'deterministic-v2',
+            settings: {
+                strict: false,
+                matchers: createMinimalMatchers(),
+            },
+        });
+        fs.writeFileSync(path.join(directories.projectDirectory, 'opencode.json'), JSON.stringify(opencodeConfig, null, 2));
+        // ── Phase timings ──
+        const totalStart = performance.now();
+        // Phase 1: Hrana server
+        const hranaStart = performance.now();
+        const dbPath = path.join(directories.dataDir, 'discord-sessions.db');
+        const hranaResult = await startHranaServer({ dbPath });
+        if (hranaResult instanceof Error) {
+            throw hranaResult;
+        }
+        process.env['KIMAKI_DB_URL'] = hranaResult;
+        const hranaMs = performance.now() - hranaStart;
+        // Phase 2: Database init
+        const dbStart = performance.now();
+        await initDatabase();
+        await setBotToken(discord.botUserId, discord.botToken);
+        await setChannelDirectory({
+            channelId: TEXT_CHANNEL_ID,
+            directory: directories.projectDirectory,
+            channelType: 'text',
+        });
+        const dbMs = performance.now() - dbStart;
+        // Phase 3+4: Discord.js login + startDiscordBot
+        // In the real cli.ts flow, login happens first (line 2077), then
+        // startDiscordBot is called with the already-logged-in client (line 2130).
+        // startDiscordBot calls login() again internally (line 1069) which is
+        // a no-op on already-connected clients. We measure them together since
+        // that's the real critical path.
+        const loginStart = performance.now();
+        botClient = createDiscordJsClient({ restUrl: discord.restUrl });
+        // Don't pre-login — let startDiscordBot handle login internally.
+        // This avoids the double-login overhead that inflates measurements.
+        const loginMs = Math.round(performance.now() - loginStart);
+        const botStart = performance.now();
+        await startDiscordBot({
+            token: discord.botToken,
+            appId: discord.botUserId,
+            discordClient: botClient,
+        });
+        const botMs = performance.now() - botStart;
+        // Phase 5: OpenCode server startup (biggest bottleneck)
+        const opencodeStart = performance.now();
+        const opencodeResult = await initializeOpencodeForDirectory(directories.projectDirectory);
+        if (opencodeResult instanceof Error) {
+            throw opencodeResult;
+        }
+        const opencodeMs = performance.now() - opencodeStart;
+        const totalMs = performance.now() - totalStart;
+        const timings = {
+            hranaServerMs: Math.round(hranaMs),
+            databaseInitMs: Math.round(dbMs),
+            discordLoginMs: Math.round(loginMs),
+            startDiscordBotMs: Math.round(botMs),
+            opencodeServerMs: Math.round(opencodeMs),
+            totalMs: Math.round(totalMs),
+        };
+        // Print timings for CI/local visibility
+        console.log('\n┌─────────────────────────────────────────────┐');
+        console.log('│         Kimaki Startup Time Breakdown       │');
+        console.log('├─────────────────────────────────────────────┤');
+        console.log(`│  Hrana server:       ${String(timings.hranaServerMs).padStart(6)} ms             │`);
+        console.log(`│  Database init:      ${String(timings.databaseInitMs).padStart(6)} ms             │`);
+        console.log(`│  Discord.js login:   ${String(timings.discordLoginMs).padStart(6)} ms             │`);
+        console.log(`│  startDiscordBot:    ${String(timings.startDiscordBotMs).padStart(6)} ms             │`);
+        console.log(`│  OpenCode server:    ${String(timings.opencodeServerMs).padStart(6)} ms             │`);
+        console.log('├─────────────────────────────────────────────┤');
+        console.log(`│  TOTAL:              ${String(timings.totalMs).padStart(6)} ms             │`);
+        console.log('└─────────────────────────────────────────────┘\n');
+        // Sanity assertions — these are baselines, not targets yet.
+        // Each phase should complete (no infinite hang).
+        expect(timings.hranaServerMs).toBeLessThan(5_000);
+        expect(timings.databaseInitMs).toBeLessThan(5_000);
+        expect(timings.discordLoginMs).toBeLessThan(10_000);
+        expect(timings.startDiscordBotMs).toBeLessThan(5_000);
+        expect(timings.opencodeServerMs).toBeLessThan(30_000);
+        expect(timings.totalMs).toBeLessThan(60_000);
+        // Verify the bot is actually functional by sending a message
+        // and getting a response (validates the full pipeline works)
+        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'startup-test ping',
+        });
+        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 10_000,
+        });
+        const reply = await discord.thread(thread.id).waitForBotReply({
+            timeout: 30_000,
+        });
+        expect(reply.content.length).toBeGreaterThan(0);
+        expect(thread.id.length).toBeGreaterThan(0);
+    }, 120_000);
+    test('measures parallel startup (discord + opencode simultaneously)', async () => {
+        // This test reuses the infrastructure from test 1 (hrana, db already up)
+        // to measure what happens when we run Discord login + OpenCode in parallel.
+        // In a fresh cold start, hrana+db init would add ~50ms on top.
+        // Stop opencode server from test 1 so we get a fresh measurement
+        await stopOpencodeServer().catch(() => { });
+        // Destroy and recreate bot client for a clean login measurement
+        if (botClient) {
+            botClient.destroy();
+            botClient = null;
+        }
+        // ── Parallel phase: Discord login + OpenCode server simultaneously ──
+        const parallelStart = performance.now();
+        const [discordResult, opencodeResult] = await Promise.all([
+            // Discord path: create client, login, start bot
+            (async () => {
+                const loginStart = performance.now();
+                const client = createDiscordJsClient({ restUrl: discord.restUrl });
+                await startDiscordBot({
+                    token: discord.botToken,
+                    appId: discord.botUserId,
+                    discordClient: client,
+                });
+                return {
+                    client,
+                    totalMs: Math.round(performance.now() - loginStart),
+                };
+            })(),
+            // OpenCode path: spawn server + wait for health
+            (async () => {
+                const start = performance.now();
+                const result = await initializeOpencodeForDirectory(directories.projectDirectory);
+                if (result instanceof Error) {
+                    throw result;
+                }
+                return { ms: Math.round(performance.now() - start) };
+            })(),
+        ]);
+        const parallelMs = Math.round(performance.now() - parallelStart);
+        botClient = discordResult.client;
+        console.log('\n┌─────────────────────────────────────────────┐');
+        console.log('│      Parallel Startup Time Breakdown        │');
+        console.log('├─────────────────────────────────────────────┤');
+        console.log(`│  Discord login+bot:  ${String(discordResult.totalMs).padStart(6)} ms             │`);
+        console.log(`│  OpenCode server:    ${String(opencodeResult.ms).padStart(6)} ms             │`);
+        console.log('├─────────────────────────────────────────────┤');
+        console.log(`│  PARALLEL TOTAL:     ${String(parallelMs).padStart(6)} ms             │`);
+        console.log(`│  (vs sequential:     ${String(discordResult.totalMs + opencodeResult.ms).padStart(6)} ms)            │`);
+        console.log('└─────────────────────────────────────────────┘\n');
+        // Parallel total should be dominated by the slower path,
+        // not the sum of both.
+        const maxSingle = Math.max(discordResult.totalMs, opencodeResult.ms);
+        expect(parallelMs).toBeLessThan(maxSingle + 500);
+    }, 120_000);
+});

package/dist/store.js

@@ -10,6 +10,7 @@ export const store = createStore(() => ({
     critiqueEnabled: true,
     verboseOpencodeServer: false,
     discordBaseUrl: 'https://discord.com',
+    gatewayToken: null,
     registeredUserCommands: [],
     threads: new Map(),
     test: { deterministicTranscription: null },