kimaki 0.4.83 → 0.4.85

package/dist/cli.js

@@ -26,7 +26,7 @@ import { createLogger, formatErrorWithStack, initLogFile, LogPrefix } from './lo
 import { initSentry, notifyError } from './sentry.js';
 import { archiveThread, uploadFilesToDiscord, stripMentions, } from './discord-utils.js';
 import { spawn, execSync } from 'node:child_process';
-import { setDataDir, getDataDir, getProjectsDir, } from './config.js';
+import { setDataDir, setProjectsDir, getDataDir, getProjectsDir, } from './config.js';
 import { execAsync } from './worktrees.js';
 import { backgroundUpgradeKimaki, upgrade, getCurrentVersion, } from './upgrade.js';
 import { startHranaServer } from './hrana-server.js';
@@ -1305,6 +1305,7 @@ cli
     .option('--restart-onboarding', 'Prompt for new credentials even if saved')
     .option('--add-channels', 'Select OpenCode projects to create Discord channels before starting')
     .option('--data-dir <path>', 'Data directory for config and database (default: ~/.kimaki)')
+    .option('--projects-dir <path>', 'Directory where new projects are created (default: <data-dir>/projects)')
     .option('--install-url', 'Print the bot install URL and exit')
     .option('--use-worktrees', 'Create git worktrees for all new sessions started from channel messages')
     .option('--enable-voice-channels', 'Create voice channels for projects (disabled by default)')
@@ -1332,6 +1333,10 @@ cli
             setDataDir(options.dataDir);
             cliLogger.log(`Using data directory: ${getDataDir()}`);
         }
+        if (options.projectsDir) {
+            setProjectsDir(options.projectsDir);
+            cliLogger.log(`Using projects directory: ${getProjectsDir()}`);
+        }
         // Initialize file logging to <dataDir>/kimaki.log
         initLogFile(getDataDir());
         // Batch all CLI flag store updates into a single setState call.
@@ -2623,6 +2628,7 @@ cli
     .option('-t, --tunnel-id [id]', 'Custom tunnel ID (only for services safe to expose publicly; prefer random default)')
     .option('-h, --host [host]', 'Local host (default: localhost)')
     .option('-s, --server [url]', 'Tunnel server URL')
+    .option('-k, --kill', 'Kill any existing process on the port before starting')
     .action(async (options) => {
     const { runTunnel, parseCommandFromArgv, CLI_NAME } = await import('traforo/run-tunnel');
     if (!options.port) {
@@ -2644,10 +2650,11 @@ cli
         baseDomain: 'kimaki.xyz',
         serverUrl: options.server,
         command: command.length > 0 ? command : undefined,
+        kill: options.kill,
     });
 });
 cli
-    .command('screenshare', 'Share your screen via VNC tunnel. Auto-stops after 1 hour. Runs until Ctrl+C. Use tmux to run in background.')
+    .command('screenshare', 'Share your screen via VNC tunnel. Auto-stops after 30 minutes. Runs until Ctrl+C. Use tmux to run in background.')
     .action(async () => {
     const { startScreenshare } = await import('./commands/screenshare.js');
     try {

package/dist/commands/screenshare.js

@@ -15,11 +15,14 @@ import { startWebsockify } from '../websockify.js';
 import { createLogger } from '../logger.js';
 import { execAsync } from '../worktrees.js';
 const logger = createLogger('SCREEN');
+const SECURE_REPLY_FLAGS = MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS;
 /** One active screenshare per guild (Discord) or per machine (CLI) */
 const activeSessions = new Map();
 const VNC_PORT = 5900;
-const MAX_SESSION_MS = 60 * 60 * 1000; // 1 hour
+const MAX_SESSION_MINUTES = 30;
+const MAX_SESSION_MS = MAX_SESSION_MINUTES * 60 * 1000;
 const TUNNEL_BASE_DOMAIN = 'kimaki.xyz';
+const SCREENSHARE_TUNNEL_ID_BYTES = 16;
 // Public noVNC client — we point it at our tunnel URL
 export function buildNoVncUrl({ tunnelHost }) {
     const params = new URLSearchParams({
@@ -32,6 +35,9 @@ export function buildNoVncUrl({ tunnelHost }) {
     });
     return `https://novnc.com/noVNC/vnc.html?${params.toString()}`;
 }
+export function createScreenshareTunnelId() {
+    return crypto.randomBytes(SCREENSHARE_TUNNEL_ID_BYTES).toString('hex');
+}
 // macOS has two separate services:
 // - "Screen Sharing" = view-only VNC (com.apple.screensharing)
 // - "Remote Management" = full control VNC with mouse/keyboard (ARDAgent)
@@ -170,7 +176,7 @@ export async function startScreenshare({ sessionKey, startedBy, }) {
         throw err;
     }
     // Step 3: create tunnel
-    const tunnelId = crypto.randomBytes(8).toString('hex');
+    const tunnelId = createScreenshareTunnelId();
     const tunnelClient = new TunnelClient({
         localPort: wsInstance.port,
         tunnelId,
@@ -197,9 +203,9 @@ export async function startScreenshare({ sessionKey, startedBy, }) {
     const tunnelHost = `${tunnelId}-tunnel.${TUNNEL_BASE_DOMAIN}`;
     const tunnelUrl = `https://${tunnelHost}`;
     const noVncUrl = buildNoVncUrl({ tunnelHost });
-    // Auto-kill after 1 hour
+    // Auto-kill after a short session so a leaked URL does not stay usable all day.
     const timeoutTimer = setTimeout(() => {
-        logger.log(`Screen share auto-stopped after 1 hour (key: ${sessionKey})`);
+        logger.log(`Screen share auto-stopped after ${MAX_SESSION_MINUTES} minutes (key: ${sessionKey})`);
         stopScreenshare({ sessionKey });
     }, MAX_SESSION_MS);
     // Don't keep the process alive just for this timer
@@ -240,14 +246,16 @@ export async function handleScreenshareCommand({ command, }) {
         });
         return;
     }
-    await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+    await command.deferReply({ flags: SECURE_REPLY_FLAGS });
     try {
         const session = await startScreenshare({
             sessionKey: guildId,
             startedBy: command.user.tag,
         });
         await command.editReply({
-            content: `Screen sharing started\n${session.noVncUrl}`,
+            content: `Screen sharing started. This reply is private and the URL uses a high-entropy tunnel id. ` +
+                `It will auto-stop after ${MAX_SESSION_MINUTES} minutes. Use /screenshare-stop to stop sooner.\n` +
+                `${session.noVncUrl}`,
         });
     }
     catch (err) {

package/dist/commands/screenshare.test.js

@@ -0,0 +1,20 @@
+import { describe, expect, test } from 'vitest';
+import { buildNoVncUrl, createScreenshareTunnelId } from './screenshare.js';
+describe('screenshare security defaults', () => {
+    test('generates a 128-bit tunnel id', () => {
+        const ids = new Set(Array.from({ length: 32 }, () => {
+            return createScreenshareTunnelId();
+        }));
+        expect(ids.size).toBe(32);
+        for (const id of ids) {
+            expect(id).toMatch(/^[0-9a-f]{32}$/);
+        }
+    });
+    test('builds a secure noVNC URL', () => {
+        const url = new URL(buildNoVncUrl({ tunnelHost: '0123456789abcdef-tunnel.kimaki.xyz' }));
+        expect(url.origin).toBe('https://novnc.com');
+        expect(url.searchParams.get('host')).toBe('0123456789abcdef-tunnel.kimaki.xyz');
+        expect(url.searchParams.get('port')).toBe('443');
+        expect(url.searchParams.get('encrypt')).toBe('1');
+    });
+});

package/dist/config.js

@@ -42,11 +42,26 @@ export function setDataDir(dir) {
 }
 /**
  * Get the projects directory path (for /create-new-project command).
- * Returns <dataDir>/projects
+ * Returns the custom --projects-dir if set, otherwise <dataDir>/projects.
  */
 export function getProjectsDir() {
+    const custom = store.getState().projectsDir;
+    if (custom) {
+        return custom;
+    }
     return path.join(getDataDir(), 'projects');
 }
+/**
+ * Set a custom projects directory path (from --projects-dir CLI flag).
+ * Creates the directory if it doesn't exist.
+ */
+export function setProjectsDir(dir) {
+    const resolvedDir = path.resolve(dir);
+    if (!fs.existsSync(resolvedDir)) {
+        fs.mkdirSync(resolvedDir, { recursive: true });
+    }
+    store.setState({ projectsDir: resolvedDir });
+}
 const DEFAULT_LOCK_PORT = 29988;
 /**
  * Derive a lock port from the data directory path.

package/dist/discord-bot.js

@@ -77,8 +77,6 @@ function describeCloseCode(code) {
     return codes[code] || 'unknown';
 }
 const shardReconnectState = new Map();
-const shardReconnectRecoveryTimeouts = new Map();
-const GATEWAY_RELOGIN_GRACE_MS = 10_000;
 function getOrCreateShardState(shardId) {
     let state = shardReconnectState.get(shardId);
     if (!state) {
@@ -144,46 +142,6 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         discordClient = await createDiscordClient();
     }
     let currentAppId = appId;
-    let runtimeHandlersRegistered = false;
-    let gatewayReloginInFlight = false;
-    const clearShardRecoveryTimeout = ({ shardId }) => {
-        const timeout = shardReconnectRecoveryTimeouts.get(shardId);
-        if (!timeout) {
-            return;
-        }
-        clearTimeout(timeout);
-        shardReconnectRecoveryTimeouts.delete(shardId);
-    };
-    const forceGatewayRelogin = ({ shardId }) => {
-        if (gatewayReloginInFlight) {
-            return;
-        }
-        gatewayReloginInFlight = true;
-        void (async () => {
-            discordLogger.warn(`[GATEWAY] Shard ${shardId} stayed reconnecting for ${GATEWAY_RELOGIN_GRACE_MS}ms, forcing client relogin`);
-            try {
-                discordClient.destroy();
-                await discordClient.login(token);
-            }
-            catch (error) {
-                discordLogger.error(`[GATEWAY] Forced relogin failed: ${formatErrorWithStack(error)}`);
-            }
-            finally {
-                gatewayReloginInFlight = false;
-            }
-        })();
-    };
-    const scheduleShardRecoveryTimeout = ({ shardId }) => {
-        clearShardRecoveryTimeout({ shardId });
-        const timeout = setTimeout(() => {
-            const state = shardReconnectState.get(shardId);
-            if (!state?.attempts) {
-                return;
-            }
-            forceGatewayRelogin({ shardId });
-        }, GATEWAY_RELOGIN_GRACE_MS);
-        shardReconnectRecoveryTimeouts.set(shardId, timeout);
-    };
     const setupHandlers = async (c) => {
         discordLogger.log(`Discord bot logged in as ${c.user.tag}`);
         discordLogger.log(`Connected to ${c.guilds.cache.size} guild(s)`);
@@ -202,12 +160,9 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         }
         voiceLogger.log('[READY] Bot is ready');
         markDiscordGatewayReady();
-        if (!runtimeHandlersRegistered) {
-            registerInteractionHandler({ discordClient: c, appId: currentAppId });
-            registerVoiceStateHandler({ discordClient: c, appId: currentAppId });
-            startExternalOpencodeSessionSync({ discordClient: c });
-            runtimeHandlersRegistered = true;
-        }
+        registerInteractionHandler({ discordClient: c, appId: currentAppId });
+        registerVoiceStateHandler({ discordClient: c, appId: currentAppId });
+        startExternalOpencodeSessionSync({ discordClient: c });
         // Channel logging is informational only; do it in background so startup stays responsive.
         void (async () => {
             for (const guild of c.guilds.cache.values()) {
@@ -226,14 +181,16 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
     };
     // If client is already ready (was logged in before being passed to us),
     // run setup immediately. Otherwise wait for the ClientReady event.
-    discordClient.on(Events.ClientReady, (readyClient) => {
-        void setupHandlers(readyClient).catch((error) => {
-            discordLogger.error(`[GATEWAY] ClientReady handler failed: ${formatErrorWithStack(error)}`);
-        });
-    });
     if (discordClient.isReady()) {
         await setupHandlers(discordClient);
     }
+    else {
+        discordClient.once(Events.ClientReady, (readyClient) => {
+            void setupHandlers(readyClient).catch((error) => {
+                discordLogger.error(`[GATEWAY] ClientReady handler failed: ${formatErrorWithStack(error)}`);
+            });
+        });
+    }
     discordClient.on(Events.Error, (error) => {
         discordLogger.error('[GATEWAY] Client error:', formatErrorWithStack(error));
     });
@@ -262,10 +219,8 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             parts.push(`last error: ${state.lastError.message}`);
         }
         discordLogger.warn(`[GATEWAY] Shard ${shardId} reconnecting: ${parts.join(', ')}`);
-        scheduleShardRecoveryTimeout({ shardId });
     });
     discordClient.on(Events.ShardResume, (shardId, replayedEvents) => {
-        clearShardRecoveryTimeout({ shardId });
         const state = shardReconnectState.get(shardId);
         if (state?.attempts) {
             discordLogger.log(`[GATEWAY] Shard ${shardId} resumed after ${state.attempts} reconnect attempt(s), ${replayedEvents} replayed events`);
@@ -279,7 +234,6 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
     // After a gateway proxy redeploy, sessions are lost (in-memory), so RESUME
     // fails with INVALID_SESSION and discord.js falls back to fresh IDENTIFY.
     discordClient.on(Events.ShardReady, (shardId) => {
-        clearShardRecoveryTimeout({ shardId });
         const state = shardReconnectState.get(shardId);
         if (state?.attempts) {
             discordLogger.log(`[GATEWAY] Shard ${shardId} ready after ${state.attempts} reconnect attempt(s)`);
@@ -287,9 +241,6 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
         shardReconnectState.delete(shardId);
     });
     discordClient.on(Events.Invalidated, () => {
-        for (const shardId of shardReconnectRecoveryTimeouts.keys()) {
-            clearShardRecoveryTimeout({ shardId });
-        }
         discordLogger.error('[GATEWAY] Session invalidated by Discord');
     });
     discordClient.on(Events.MessageCreate, async (message) => {
@@ -646,6 +597,8 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     prompt: '',
                     userId: message.author.id,
                     username: message.member?.displayName || message.author.displayName,
+                    sourceMessageId: message.id,
+                    sourceThreadId: thread.id,
                     appId: currentAppId,
                     preprocess: () => {
                         return preprocessNewThreadMessage({

package/dist/discord-command-registration.js

@@ -360,7 +360,7 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .toJSON(),
         new SlashCommandBuilder()
             .setName('screenshare')
-            .setDescription(truncateCommandDescription('Start screen sharing via VNC tunnel (auto-stops after 1 hour)'))
+            .setDescription(truncateCommandDescription('Start screen sharing via VNC tunnel (auto-stops after 30 minutes)'))
             .setDMPermission(false)
             .toJSON(),
         new SlashCommandBuilder()

package/dist/external-opencode-sync.js

@@ -19,7 +19,7 @@ function isSyntheticTextPart(part) {
     return candidate.synthetic === true;
 }
 function parseDiscordOriginMetadata(text) {
-    const match = text.match(/^<discord-user\s+([^>]+)\s*\/>$/);
+    const match = text.match(/<discord-user\s+([^>]+)\s*\/>/);
     if (!match?.[1]) {
         return null;
     }
@@ -31,29 +31,28 @@ function parseDiscordOriginMetadata(text) {
         acc[key] = value || '';
         return acc;
     }, {});
-    const messageId = attrs['message-id'];
     const username = attrs['name'];
-    if (!messageId || !username) {
+    if (!username) {
         return null;
     }
     return {
-        messageId,
+        messageId: attrs['message-id'] || undefined,
         username,
         threadId: attrs['thread-id'] || undefined,
     };
 }
 function getDiscordOriginMetadataFromMessage({ message, }) {
-    const syntheticTexts = message.parts.flatMap((part) => {
-        if (part.type !== 'text') {
-            return [];
-        }
-        if (!isSyntheticTextPart(part)) {
-            return [];
-        }
-        return [part.text || ''];
+    const textParts = message.parts.filter((p) => {
+        return p.type === 'text';
     });
-    for (const text of syntheticTexts) {
-        const metadata = parseDiscordOriginMetadata(text);
+    // Synthetic parts first (normal promptAsync path), then non-synthetic
+    // (session.command() path where the tag is embedded in arguments text).
+    const sorted = [
+        ...textParts.filter((p) => { return isSyntheticTextPart(p); }),
+        ...textParts.filter((p) => { return !isSyntheticTextPart(p); }),
+    ];
+    for (const part of sorted) {
+        const metadata = parseDiscordOriginMetadata(part.text || '');
         if (metadata) {
             return metadata;
         }
@@ -81,14 +80,13 @@ function getRenderableUserTextParts({ message, }) {
 function getExternalUserMirrorText({ username, prompt, }) {
     return `» **${username}:** ${prompt.slice(0, 1000)}${prompt.length > 1000 ? '...' : ''}`;
 }
-// Pure derivation: does the latest user turn come from outside this
-// Discord thread and contain parts we haven't mirrored yet?
-// Used to reclaim sync for kimaki-owned threads when the user resumes
-// from the OpenCode CLI/TUI side. No new state — derives from existing
-// part_messages dedupe set and <discord-user /> origin tags.
-function hasExternalResume({ messages, threadId, syncedPartIds, }) {
-    // Walk messages newest-first to find the latest user message
-    // with renderable text content.
+// Pure derivation: is the latest user turn from Discord?
+// Checks the newest user message with renderable text for a <discord-user />
+// synthetic part. If present, the session is currently driven from Discord
+// (kimaki manages it) and external sync should skip it. If absent (CLI/TUI),
+// external sync should mirror it — this naturally handles the "reclaim" case
+// (external → discord → external) without any DB source toggling.
+function isLatestUserTurnFromDiscord({ messages, }) {
     for (let i = messages.length - 1; i >= 0; i--) {
         const message = messages[i];
         if (message.info.role !== 'user') {
@@ -99,18 +97,10 @@ function hasExternalResume({ messages, threadId, syncedPartIds, }) {
             continue;
         }
         // Found the latest user message with actual text content.
-        // Check if it originated from this Discord thread.
-        const origin = getDiscordOriginMetadataFromMessage({ message });
-        if (origin && (!origin.threadId || origin.threadId === threadId)) {
-            // Latest user turn came from Discord — no external resume.
-            return false;
-        }
-        // Latest user turn is external (CLI/TUI). Check if we already
-        // mirrored all its parts. If any part is unseen, reclaim.
-        return renderableParts.some((p) => {
-            return !syncedPartIds.has(p.id);
-        });
+        // If it has <discord-user /> origin metadata, it came from Discord.
+        return getDiscordOriginMetadataFromMessage({ message }) !== null;
     }
+    // No user messages with text — treat as external (allow sync).
     return false;
 }
 function shouldMirrorAssistantPart({ part, verbosity, }) {
@@ -177,16 +167,14 @@ function groupTrackedChannelsByDirectory(trackedChannels) {
     }, new Map());
     return [...grouped.values()];
 }
-async function ensureExternalSessionThread({ discordClient, channelId, sessionId, sessionTitle, messages, reclaimable, }) {
+async function ensureExternalSessionThread({ discordClient, channelId, sessionId, sessionTitle, messages, }) {
     const existingThreadId = await getThreadIdBySessionId(sessionId);
     if (existingThreadId) {
+        // Caller already verified via isLatestUserTurnFromDiscord that this
+        // session should be synced. If the thread was kimaki-owned, flip it
+        // to external_poll so typing and future polls work naturally.
         const existingSource = await getThreadSessionSource(existingThreadId);
-        if (existingSource && existingSource !== 'external_poll' && !reclaimable) {
-            return null;
-        }
-        // Reclaim: flip kimaki-owned thread back to external_poll so typing
-        // and future polls work naturally without any new stored state.
-        if (existingSource === 'kimaki' && reclaimable) {
+        if (existingSource === 'kimaki') {
             await upsertThreadSession({
                 threadId: existingThreadId,
                 sessionId,
@@ -250,14 +238,16 @@ function collectUnsyncedChunks({ messages, syncedPartIds, verbosity, thread, })
             if (unsyncedParts.length === 0) {
                 continue;
             }
-            // If the user message came from this Discord thread, record the
-            // mapping to the original Discord message without sending a new one.
+            // If the user message came from this Discord thread, skip mirroring
+            // — it's already visible. When message-id is available, record a
+            // direct mapping for part dedup. When it's missing (sourceMessageId
+            // is optional in IngressInput), just mark parts as synced.
             const discordOrigin = getDiscordOriginMetadataFromMessage({ message });
             if (discordOrigin && (!discordOrigin.threadId || discordOrigin.threadId === thread.id)) {
                 unsyncedParts.forEach((part) => {
                     directMappings.push({
                         partId: part.id,
-                        messageId: discordOrigin.messageId,
+                        messageId: discordOrigin.messageId || '',
                         threadId: thread.id,
                     });
                     syncedPartIds.add(part.id);
@@ -312,24 +302,12 @@ async function syncSessionToThread({ client, discordClient, directory, channelId
         throw messagesResponse;
     }
     const messages = messagesResponse.data || [];
-    // Pre-check: for kimaki-owned threads, derive whether the user resumed
-    // from the OpenCode CLI/TUI by inspecting the latest user turn and
-    // existing part_messages. No new state — pure derivation from evidence.
-    const existingThreadId = await getThreadIdBySessionId(sessionId);
-    let reclaimable = false;
-    if (existingThreadId) {
-        const existingSource = await getThreadSessionSource(existingThreadId);
-        if (existingSource === 'kimaki') {
-            const existingPartIds = await getPartMessageIds(existingThreadId);
-            reclaimable = hasExternalResume({
-                messages,
-                threadId: existingThreadId,
-                syncedPartIds: new Set(existingPartIds),
-            });
-            if (!reclaimable) {
-                return;
-            }
-        }
+    // Pure derivation from opencode events: if the latest user turn has
+    // <discord-user /> metadata, kimaki's thread runtime owns this session.
+    // Skip external sync entirely. When the user resumes from CLI/TUI the
+    // latest user turn will lack the tag, so sync picks it up naturally.
+    if (isLatestUserTurnFromDiscord({ messages })) {
+        return;
     }
     const thread = await ensureExternalSessionThread({
         discordClient,
@@ -337,7 +315,6 @@ async function syncSessionToThread({ client, discordClient, directory, channelId
         sessionId,
         sessionTitle,
         messages,
-        reclaimable,
     });
     if (thread === null) {
         return;
@@ -534,5 +511,5 @@ export const externalOpencodeSyncInternals = {
     sortSessionsByRecency,
     parseDiscordOriginMetadata,
     getDiscordOriginMetadataFromMessage,
-    hasExternalResume,
+    isLatestUserTurnFromDiscord,
 };

package/dist/gateway-proxy.e2e.test.js

@@ -98,13 +98,6 @@ function createMatchers() {
     };
     return [defaultReply];
 }
-function waitForChildExit(child) {
-    return new Promise((resolve) => {
-        child.once('exit', () => {
-            resolve();
-        });
-    });
-}
 async function waitForProxyReady({ port, timeoutMs = 30_000, }) {
     const start = Date.now();
     while (Date.now() - start < timeoutMs) {
@@ -334,7 +327,7 @@ describeIf('gateway-proxy e2e', () => {
       `);
         expect(reply).toBeDefined();
         expect(reply.content.trim().length).toBeGreaterThan(0);
-    }, 30_000);
+    }, 15_000);
     test('follow-up message in thread gets bot reply', async () => {
         const existingMessages = await discord.thread(firstThreadId).getMessages();
         const existingIds = new Set(existingMessages.map((m) => m.id));
@@ -347,7 +340,7 @@ describeIf('gateway-proxy e2e', () => {
         await waitForFooterMessage({
             discord,
             threadId: firstThreadId,
-            timeout: 15_000,
+            timeout: 4_000,
             afterMessageIncludes: 'follow up through proxy',
             afterAuthorId: TEST_USER_ID,
         });
@@ -365,51 +358,10 @@ describeIf('gateway-proxy e2e', () => {
       `);
         expect(reply).toBeDefined();
         expect(reply.content.trim().length).toBeGreaterThan(0);
-    }, 30_000);
-    test('bot recovers after gateway proxy restart', async () => {
-        const exitPromise = waitForChildExit(proxyProcess);
-        proxyProcess.kill('SIGTERM');
-        await exitPromise;
-        const restartedProxy = startGatewayProxy({
-            configDir: path.join(directories.dataDir, 'proxy'),
-            port: proxyPort,
-            twinPort: discord.port,
-            botToken: discord.botToken,
-            gatewayUrl: discord.gatewayUrl,
-        });
-        proxyProcess = restartedProxy.process;
-        await waitForProxyReady({ port: proxyPort, timeoutMs: 30_000 });
-        await new Promise((resolve) => {
-            setTimeout(resolve, 6_000);
-        });
-        await discord.channel(CHANNEL_1_ID).user(TEST_USER_ID).sendMessage({
-            content: 'recovered after proxy restart',
-        });
-        const recoveryThread = await discord.channel(CHANNEL_1_ID).waitForThread({
-            timeout: 30_000,
-            predicate: (t) => {
-                return t.name?.includes('recovered after proxy restart') ?? false;
-            },
-        });
-        const reply = await discord.thread(recoveryThread.id).waitForBotReply({
-            timeout: 30_000,
-        });
-        await waitForFooterMessage({
-            discord,
-            threadId: recoveryThread.id,
-            timeout: 30_000,
-            afterMessageIncludes: 'recovered after proxy restart',
-            afterAuthorId: TEST_USER_ID,
-        });
-        expect(await discord.thread(recoveryThread.id).text()).toMatchInlineSnapshot(`
-        "--- from: user (proxy-tester)
-        recovered after proxy restart
-        --- from: assistant (TestBot)
-        ⬥ gateway-proxy-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `);
-        expect(reply.content.trim().length).toBeGreaterThan(0);
-    }, 60_000);
+    }, 15_000);
+    // Reconnect test lives in gateway-proxy-reconnect.e2e.test.ts.
+    // It was here before but kills the proxy mid-suite, breaking shared
+    // state (bot/proxy connection) for all subsequent tests.
     test('shell command via ! prefix in thread', async () => {
         const existingMessages = await discord.thread(firstThreadId).getMessages();
         const existingIds = new Set(existingMessages.map((m) => m.id));
@@ -463,7 +415,7 @@ describeIf('gateway-proxy e2e', () => {
       `);
         expect(reply).toBeDefined();
         expect(reply.content.trim().length).toBeGreaterThan(0);
-    }, 30_000);
+    }, 15_000);
     test('guild-2 message does not create thread (guild isolation)', async () => {
         await discord.channel(CHANNEL_2_ID).user(TEST_USER_ID).sendMessage({
             content: 'should not create thread in guild 2',
@@ -526,5 +478,5 @@ describeIf('gateway-proxy e2e', () => {
         finally {
             store.setState({ discordBaseUrl: previousBaseUrl });
         }
-    }, 30_000);
+    }, 15_000);
 });

package/dist/onboarding-tutorial.js

@@ -142,7 +142,7 @@ ${backticks}bash
 PORT=$((RANDOM % 6000 + 3000))
 tmux kill-session -t game-dev 2>/dev/null
 tmux new-session -d -s game-dev -c "$PWD"
-tmux send-keys -t game-dev "PORT=$PORT kimaki tunnel -p $PORT -- bun run server.ts" Enter
+tmux send-keys -t game-dev "PORT=$PORT kimaki tunnel --kill -p $PORT -- bun run server.ts" Enter
 ${backticks}
 
 Wait a moment, then get the tunnel URL:

package/dist/queue-advanced-e2e-setup.js

@@ -299,6 +299,41 @@ export function createDeterministicMatchers() {
             ],
         },
     };
+    // Question tool for select+queue drain test: model asks a question via dropdown,
+    // user answers via select menu while a message is queued.
+    const questionSelectQueueMatcher = {
+        id: 'question-select-queue-marker',
+        priority: 107,
+        when: {
+            lastMessageRole: 'user',
+            latestUserTextIncludes: 'QUESTION_SELECT_QUEUE_MARKER',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                {
+                    type: 'tool-call',
+                    toolCallId: 'question-select-queue-call',
+                    toolName: 'question',
+                    input: JSON.stringify({
+                        questions: [{
+                                question: 'How to proceed?',
+                                header: 'Select action',
+                                options: [
+                                    { label: 'Alpha', description: 'Alpha option' },
+                                    { label: 'Beta', description: 'Beta option' },
+                                ],
+                            }],
+                    }),
+                },
+                {
+                    type: 'finish',
+                    finishReason: 'tool-calls',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+        },
+    };
     // Model responds with text + tool call, then after tool result the
     // follow-up matcher responds with text. This creates two assistant messages:
     // first with finish="tool-calls" + completed, second with finish="stop".
@@ -613,6 +648,7 @@ export function createDeterministicMatchers() {
         pluginTimeoutSleepMatcher,
         actionButtonClickFollowupMatcher,
         questionToolMatcher,
+        questionSelectQueueMatcher,
         permissionTypingMatcher,
         permissionTypingFollowupMatcher,
         multiToolMatcher,