@otto-assistant/bridge 0.4.92

package/dist/session-handler.js

@@ -0,0 +1,9 @@
+// Thin re-export shim for backward compatibility.
+// Logic lives in:
+//   - session-handler/thread-session-runtime.ts (runtime class + registry)
+//   - session-handler/thread-runtime-state.ts (state transitions)
+//   - session-handler/model-utils.ts (getDefaultModel, types)
+//   - session-handler/agent-utils.ts (resolveValidatedAgentPreference)
+// New code should import from the specific module directly.
+export { getDefaultModel, } from './session-handler/model-utils.js';
+export { resolveValidatedAgentPreference } from './session-handler/agent-utils.js';

package/dist/session-search.js

@@ -0,0 +1,100 @@
+// Session search helpers for kimaki CLI commands.
+// Parses string/regex queries and builds readable snippets from matched content.
+export function parseSessionSearchPattern(query) {
+    const trimmedQuery = query.trim();
+    if (!trimmedQuery) {
+        return new Error('Search query cannot be empty');
+    }
+    const regexMatch = trimmedQuery.match(/^\/([\s\S]+)\/([a-z]*)$/);
+    if (!regexMatch) {
+        return {
+            mode: 'literal',
+            raw: trimmedQuery,
+            normalizedNeedle: trimmedQuery.toLowerCase(),
+        };
+    }
+    const pattern = regexMatch[1] || '';
+    const flags = regexMatch[2] || '';
+    try {
+        return {
+            mode: 'regex',
+            raw: trimmedQuery,
+            regex: new RegExp(pattern, flags),
+        };
+    }
+    catch (error) {
+        return new Error(`Invalid regex query "${trimmedQuery}": ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export function findFirstSessionSearchHit({ text, searchPattern, }) {
+    if (searchPattern.mode === 'literal') {
+        const index = text.toLowerCase().indexOf(searchPattern.normalizedNeedle);
+        if (index < 0) {
+            return undefined;
+        }
+        return {
+            index,
+            length: searchPattern.raw.length,
+        };
+    }
+    searchPattern.regex.lastIndex = 0;
+    const match = searchPattern.regex.exec(text);
+    if (!match || match.index < 0) {
+        return undefined;
+    }
+    return {
+        index: match.index,
+        length: Math.max(match[0]?.length || 0, 1),
+    };
+}
+export function buildSessionSearchSnippet({ text, hit, contextLength = 90, }) {
+    const start = Math.max(0, hit.index - contextLength);
+    const end = Math.min(text.length, hit.index + hit.length + contextLength);
+    const prefix = start > 0 ? '...' : '';
+    const suffix = end < text.length ? '...' : '';
+    const body = text
+        .slice(start, end)
+        .replace(/[\r\n\t]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return `${prefix}${body}${suffix}`;
+}
+function stringifyUnknown(value) {
+    if (value === undefined || value === null) {
+        return '';
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+export function getPartSearchTexts(part) {
+    switch (part.type) {
+        case 'text':
+            return part.text ? [part.text] : [];
+        case 'reasoning':
+            return part.text ? [part.text] : [];
+        case 'tool': {
+            const inputText = stringifyUnknown(part.state.input);
+            const outputText = part.state.status === 'completed'
+                ? stringifyUnknown(part.state.output)
+                : part.state.status === 'error'
+                    ? part.state.error || ''
+                    : '';
+            return [`tool:${part.tool}`, inputText, outputText].filter((entry) => {
+                return entry.trim().length > 0;
+            });
+        }
+        case 'file':
+            return [part.filename || '', part.url || ''].filter((entry) => {
+                return entry.trim().length > 0;
+            });
+        default:
+            return [];
+    }
+}

package/dist/session-search.test.js

@@ -0,0 +1,40 @@
+// Tests for session search query parsing and snippet matching helpers.
+import { describe, expect, test } from 'vitest';
+import { buildSessionSearchSnippet, findFirstSessionSearchHit, parseSessionSearchPattern, } from './session-search.js';
+describe('session search helpers', () => {
+    test('returns error for invalid regex query', () => {
+        const parsed = parseSessionSearchPattern('/(unclosed/');
+        expect(parsed).toBeInstanceOf(Error);
+    });
+    test('returns snippets that include the matched substring', () => {
+        const cases = [
+            {
+                query: 'panic',
+                text: 'There was a PANIC in production',
+                expectedSubstring: 'PANIC',
+            },
+            {
+                query: '/error\\s+42/i',
+                text: 'Request failed with ERROR 42 in worker',
+                expectedSubstring: 'ERROR 42',
+            },
+        ];
+        cases.forEach(({ query, text, expectedSubstring }) => {
+            const parsed = parseSessionSearchPattern(query);
+            if (parsed instanceof Error) {
+                throw parsed;
+            }
+            const hit = findFirstSessionSearchHit({ text, searchPattern: parsed });
+            expect(hit).toBeDefined();
+            if (!hit) {
+                return;
+            }
+            const snippet = buildSessionSearchSnippet({
+                text,
+                hit,
+                contextLength: 8,
+            });
+            expect(snippet.toUpperCase()).toContain(expectedSubstring.toUpperCase());
+        });
+    });
+});

package/dist/session-title-rename.test.js

@@ -0,0 +1,80 @@
+// Unit tests for deriveThreadNameFromSessionTitle — the pure helper that
+// decides whether (and how) to rename a Discord thread based on an
+// OpenCode session title. Kept focused and deterministic; no Discord mocks.
+import { describe, test, expect } from 'vitest';
+import { deriveThreadNameFromSessionTitle } from './session-handler/thread-session-runtime.js';
+describe('deriveThreadNameFromSessionTitle', () => {
+    test('returns trimmed title for plain thread', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: '  Fix auth bug  ',
+            currentName: 'fix the auth',
+        })).toMatchInlineSnapshot(`"Fix auth bug"`);
+    });
+    test('preserves worktree prefix from current name', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: 'Refactor queue',
+            currentName: '⬦ refactor queue old',
+        })).toMatchInlineSnapshot(`"⬦ Refactor queue"`);
+    });
+    test('ignores placeholder "New Session -" titles', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: 'New Session - 2025-01-02',
+            currentName: 'whatever',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+    test('ignores case-insensitive placeholder titles', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: 'new session -abc',
+            currentName: 'whatever',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+    test('returns undefined when candidate already matches current name', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: 'Fix auth bug',
+            currentName: 'Fix auth bug',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+    test('returns undefined when candidate (with worktree prefix) already matches', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: 'Refactor queue',
+            currentName: '⬦ Refactor queue',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+    test('truncates to 100 chars including worktree prefix', () => {
+        const result = deriveThreadNameFromSessionTitle({
+            sessionTitle: 'x'.repeat(200),
+            currentName: '⬦ seed',
+        });
+        expect(result?.length).toMatchInlineSnapshot(`100`);
+        expect(result?.startsWith('⬦ ')).toMatchInlineSnapshot(`true`);
+    });
+    test('truncates to 100 chars without prefix', () => {
+        const result = deriveThreadNameFromSessionTitle({
+            sessionTitle: 'y'.repeat(200),
+            currentName: 'seed',
+        });
+        expect(result?.length).toMatchInlineSnapshot(`100`);
+    });
+    test('returns undefined for empty string', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: '',
+            currentName: 'seed',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+    test('returns undefined for whitespace-only title', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: '   ',
+            currentName: 'seed',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+    test('returns undefined for null/undefined title', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: null,
+            currentName: 'seed',
+        })).toMatchInlineSnapshot(`undefined`);
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: undefined,
+            currentName: 'seed',
+        })).toMatchInlineSnapshot(`undefined`);
+    });
+});

package/dist/startup-service.js

@@ -0,0 +1,153 @@
+// Cross-platform startup service registration for kimaki daemon.
+// Vendored from startup-run (MIT, github.com/vilicvane/startup-run) with
+// significant simplifications: no abstract classes, no fs-extra, no winreg
+// npm dep, no separate daemon process (kimaki's bin.ts already handles
+// respawn/crash-loop). Just writes/deletes the platform service file.
+//
+// macOS:   ~/Library/LaunchAgents/xyz.kimaki.plist  (launchd)
+// Linux:   ~/.config/autostart/kimaki.desktop       (XDG autostart)
+// Windows: HKCU\Software\Microsoft\Windows\CurrentVersion\Run  (registry)
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execAsync } from './worktrees.js';
+const SERVICE_NAME = 'xyz.kimaki';
+function getServiceFilePath() {
+    switch (process.platform) {
+        case 'darwin':
+            return path.join(os.homedir(), 'Library', 'LaunchAgents', `${SERVICE_NAME}.plist`);
+        case 'linux':
+            return path.join(os.homedir(), '.config', 'autostart', 'kimaki.desktop');
+        case 'win32':
+            // No file — registry key, return a descriptive string for status display
+            return 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run\\kimaki';
+        default:
+            throw new Error(`Unsupported platform: ${process.platform}`);
+    }
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+// Shell-escape a string for use in a Linux .desktop Exec= line.
+// Wraps in double quotes if it contains spaces or special chars.
+function shellEscape(value) {
+    if (/^[a-zA-Z0-9._/=-]+$/.test(value)) {
+        return value;
+    }
+    return `"${value.replace(/"/g, '\\"')}"`;
+}
+function buildMacOSPlist({ command, args, }) {
+    const segments = [command, ...args];
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${SERVICE_NAME}</string>
+  <key>ProgramArguments</key>
+  <array>
+${segments.map((s) => `    <string>${escapeXml(s)}</string>`).join('\n')}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+</dict>
+</plist>
+`;
+}
+function buildLinuxDesktop({ command, args, }) {
+    const execLine = [command, ...args].map(shellEscape).join(' ');
+    return `[Desktop Entry]
+Type=Application
+Version=1.0
+Name=Kimaki
+Comment=Kimaki Discord Bot Daemon
+Exec=${execLine}
+StartupNotify=false
+Terminal=false
+`;
+}
+/**
+ * Register kimaki to start on user login.
+ * Writes the appropriate service file for the current platform.
+ */
+export async function enableStartupService({ command, args, }) {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        const filePath = getServiceFilePath();
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, buildMacOSPlist({ command, args }));
+    }
+    else if (platform === 'linux') {
+        const filePath = getServiceFilePath();
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, buildLinuxDesktop({ command, args }));
+    }
+    else if (platform === 'win32') {
+        const execLine = [command, ...args]
+            .map((s) => {
+            return s.includes(' ') ? `"${s}"` : s;
+        })
+            .join(' ');
+        await execAsync(`reg add "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v kimaki /t REG_SZ /d "${execLine}" /f`);
+    }
+    else {
+        throw new Error(`Unsupported platform: ${platform}`);
+    }
+}
+/**
+ * Unregister kimaki from user login startup.
+ */
+export async function disableStartupService() {
+    const platform = process.platform;
+    if (platform === 'darwin' || platform === 'linux') {
+        const filePath = getServiceFilePath();
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+        }
+    }
+    else if (platform === 'win32') {
+        await execAsync(`reg delete "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v kimaki /f`).catch(() => {
+            // Key may not exist, ignore
+        });
+    }
+    else {
+        throw new Error(`Unsupported platform: ${platform}`);
+    }
+}
+/**
+ * Check if kimaki is registered as a startup service.
+ */
+export async function isStartupServiceEnabled() {
+    const platform = process.platform;
+    if (platform === 'darwin' || platform === 'linux') {
+        return fs.existsSync(getServiceFilePath());
+    }
+    if (platform === 'win32') {
+        const result = await execAsync(`reg query "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v kimaki`).catch(() => {
+            return null;
+        });
+        return result !== null;
+    }
+    return false;
+}
+/**
+ * Get a human-readable description of the service location for status display.
+ */
+export function getServiceLocationDescription() {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        return `launchd: ${getServiceFilePath()}`;
+    }
+    if (platform === 'linux') {
+        return `XDG autostart: ${getServiceFilePath()}`;
+    }
+    if (platform === 'win32') {
+        return `registry: ${getServiceFilePath()}`;
+    }
+    return `unsupported platform: ${platform}`;
+}

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

@@ -0,0 +1,296 @@
+// 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, initTestGitRepo } 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 });
+    initTestGitRepo(projectDirectory);
+    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);
+});