kimaki 0.26.0 → 0.27.0

package/dist/kimaki-workspace-adaptor.js

@@ -7,7 +7,7 @@
 // Never use console.log/console.error — plugins must be silent.
 import crypto from 'node:crypto';
 import path from 'node:path';
-import { createWorktreeCore, removeWorktreeCore } from './git-worktree-core.js';
+import { createWorktreeCore, KIMAKI_WORKTREE_ADAPTER_TYPE, removeWorktreeFromOwnRepository, } from './git-worktree-core.js';
 /**
  * Compute the on-disk directory for a managed worktree.
  * Mirrors getManagedWorktreeDirectory from worktrees.ts but reads KIMAKI_DATA_DIR
@@ -29,14 +29,36 @@ function computeWorktreeDirectory({ projectDirectory, branchName, }) {
         .replaceAll('/', '-');
     return path.join(dataDir, 'worktrees', projectHash, withoutPrefix);
 }
-function createKimakiWorktreeAdaptor(projectDirectory) {
+function getWorktreeIdentity(info) {
+    if (!info.extra || typeof info.extra !== 'object') {
+        return new Error('Kimaki worktree identity is missing');
+    }
+    const identity = {};
+    Object.assign(identity, info.extra);
+    if (typeof identity.projectDirectory !== 'string' ||
+        !path.isAbsolute(identity.projectDirectory)) {
+        return new Error('Kimaki worktree project directory must be absolute');
+    }
+    if (typeof identity.baseCommit !== 'string' ||
+        !/^[0-9a-f]{40}$/i.test(identity.baseCommit)) {
+        return new Error('Kimaki worktree base commit must be a full commit SHA');
+    }
+    return {
+        projectDirectory: identity.projectDirectory,
+        baseCommit: identity.baseCommit,
+    };
+}
+function createKimakiWorktreeAdaptor() {
     return {
         name: 'Kimaki Worktree',
         description: 'Create a git worktree managed by Kimaki',
         configure(info) {
+            const identity = getWorktreeIdentity(info);
+            if (identity instanceof Error)
+                throw identity;
             const branchName = info.branch || info.name;
             const directory = computeWorktreeDirectory({
-                projectDirectory,
+                projectDirectory: identity.projectDirectory,
                 branchName,
             });
             if (directory instanceof Error) {
@@ -53,12 +75,14 @@ function createKimakiWorktreeAdaptor(projectDirectory) {
             if (!info.directory) {
                 throw new Error('Workspace directory not set — configure() likely failed');
             }
-            const baseBranch = info.extra?.baseBranch || undefined;
+            const identity = getWorktreeIdentity(info);
+            if (identity instanceof Error)
+                throw identity;
             const result = await createWorktreeCore({
-                projectDirectory,
+                projectDirectory: identity.projectDirectory,
                 targetDirectory: info.directory,
                 branchName: info.branch || info.name,
-                baseBranch,
+                baseCommit: identity.baseCommit,
                 // Silent log — plugin must not write to stdout/stderr
             });
             if (result instanceof Error) {
@@ -68,8 +92,7 @@ function createKimakiWorktreeAdaptor(projectDirectory) {
         async remove(info) {
             if (!info.directory)
                 return;
-            const result = await removeWorktreeCore({
-                projectDirectory,
+            const result = await removeWorktreeFromOwnRepository({
                 worktreeDirectory: info.directory,
                 branchName: info.branch || '',
             });
@@ -89,7 +112,7 @@ function createKimakiWorktreeAdaptor(projectDirectory) {
  * Plugin entrypoint — registers the kimaki-worktree adaptor.
  * Called by OpenCode's plugin loader.
  */
-export const kimakiWorkspaceAdaptorPlugin = async ({ directory, experimental_workspace, }) => {
-    experimental_workspace.register('kimaki-worktree', createKimakiWorktreeAdaptor(directory));
+export const kimakiWorkspaceAdaptorPlugin = async ({ experimental_workspace, }) => {
+    experimental_workspace.register(KIMAKI_WORKTREE_ADAPTER_TYPE, createKimakiWorktreeAdaptor());
     return {};
 };

package/dist/logger.js

@@ -95,7 +95,16 @@ function formatArg(arg) {
 }
 export function formatErrorWithStack(error) {
     if (error instanceof Error) {
-        return sanitizeSensitiveText(error.stack ?? `${error.name}: ${error.message}`, { redactPaths: false });
+        const seen = new Set();
+        const parts = [];
+        let current = error;
+        while (current instanceof Error && !seen.has(current)) {
+            seen.add(current);
+            const formatted = sanitizeSensitiveText(current.stack ?? `${current.name}: ${current.message}`, { redactPaths: false });
+            parts.push(parts.length === 0 ? formatted : `Caused by: ${formatted}`);
+            current = current.cause;
+        }
+        return parts.join('\n');
     }
     if (typeof error === 'string') {
         return sanitizeSensitiveText(error, { redactPaths: false });

package/dist/markdown.js

@@ -104,7 +104,9 @@ export class ShareMarkdown {
             }
         }
         else if (message.role === 'assistant') {
-            lines.push(`### 🤖 Assistant (${message.modelID || 'unknown model'})`);
+            const modelId = [message.providerID, message.modelID].filter(Boolean).join('/') ||
+                'unknown model';
+            lines.push(`### 🤖 Assistant (${modelId})`);
             lines.push('');
             // Filter and process parts
             const filteredParts = parts.filter((part) => {

package/dist/markdown.test.js

@@ -102,6 +102,10 @@ beforeAll(async () => {
     await client.session.promptAsync({
         sessionID,
         directory: directories.projectDirectory,
+        model: {
+            providerID: 'deterministic-provider',
+            modelID: 'deterministic-v2',
+        },
         parts: [{ type: 'text', text: 'hello markdown test' }],
     });
     // Wait for assistant text parts to be fully written (not just message existence).
@@ -139,6 +143,10 @@ beforeAll(async () => {
     await client.session.promptAsync({
         sessionID: toolSessionID,
         directory: directories.projectDirectory,
+        model: {
+            providerID: 'deterministic-provider',
+            modelID: 'deterministic-v2',
+        },
         parts: [{ type: 'text', text: 'use a tool please' }],
     });
     // Wait for tool execution to complete
@@ -200,7 +208,7 @@ test('generate markdown with system info', async () => {
     expect(markdown).toContain('## Conversation');
     expect(markdown).toContain('### 👤 User');
     expect(markdown).toContain('hello markdown test');
-    expect(markdown).toContain('### 🤖 Assistant');
+    expect(markdown).toContain('### 🤖 Assistant (deterministic-provider/deterministic-v2)');
     expect(markdown).toContain('Hello! This is a deterministic markdown test response.');
     expect(markdown).toContain('**Started using deterministic-provider/deterministic-v2**');
     const normalized = normalizeMarkdown(markdown);
@@ -220,7 +228,7 @@ test('generate markdown with system info', async () => {
     hello markdown test
 
 
-    ### 🤖 Assistant (deterministic-v2)
+    ### 🤖 Assistant (deterministic-provider/deterministic-v2)
 
     **Started using deterministic-provider/deterministic-v2**
 
@@ -253,7 +261,7 @@ test('generate markdown without system info', async () => {
     hello markdown test
 
 
-    ### 🤖 Assistant (deterministic-v2)
+    ### 🤖 Assistant (deterministic-provider/deterministic-v2)
 
     **Started using deterministic-provider/deterministic-v2**
 

package/dist/message-formatting.js

@@ -444,6 +444,21 @@ export function getToolSummaryText(part) {
         const prompt = part.state.input?.prompt || '';
         return prompt ? `*${escapeInlineMarkdown(prompt.slice(0, 60))}*` : '';
     }
+    // LESSON: tool parts are sent to Discord at `running` status (see
+    // shouldSendPart in thread-session-runtime), so `state.title` from the tool
+    // result is never rendered here. Everything shown must come from state.input.
+    // `until` is already absolute; `duration` is relative, so say "for 2h" —
+    // never "until 2h".
+    if (part.tool.endsWith('kimaki_sleep')) {
+        const until = part.state.input?.until || '';
+        const duration = part.state.input?.duration || '';
+        const reason = part.state.input?.reason || '';
+        const when = until ? `until ${until}` : duration ? `for ${duration}` : '';
+        const reasonText = reason ? `_${escapeInlineMarkdown(reason)}_` : '';
+        return [when && escapeInlineMarkdown(when), reasonText]
+            .filter(Boolean)
+            .join(' ');
+    }
     if (!part.state.input)
         return '';
     const inputFields = Object.entries(part.state.input)
@@ -478,15 +493,11 @@ export function formatTodoList(part) {
     return `${num} **${escapeInlineMarkdown(content)}**`;
 }
 export function formatTaskToolTitle(part) {
-    if (part.tool !== 'task' || part.state.status === 'pending')
-        return '';
-    const childSessionId = part.state.metadata?.sessionId;
-    if (typeof childSessionId !== 'string' || !childSessionId)
+    // Running only. The child session can be created later when many tasks queue.
+    if (part.tool !== 'task' || part.state.status !== 'running')
         return '';
     const description = part.state.input?.description;
-    const stateTitle = part.state.status === 'running' || part.state.status === 'completed'
-        ? part.state.title
-        : undefined;
+    const stateTitle = part.state.title;
     const title = typeof description === 'string' && description
         ? description
         : typeof stateTitle === 'string'

package/dist/message-formatting.test.js

@@ -46,24 +46,71 @@ describe('formatPart', () => {
     });
 });
 describe('formatTaskToolTitle', () => {
-    test('uses the completed task title when OpenAI omits the description', () => {
-        const part = {
+    function taskPart({ status, input = {}, title = '', sessionId, }) {
+        const base = {
             id: 'prt_task',
             type: 'tool',
             tool: 'task',
             callID: 'call_task',
             sessionID: 'ses_parent',
             messageID: 'msg_assistant',
+        };
+        if (status === 'completed') {
+            return {
+                ...base,
+                state: {
+                    status,
+                    input,
+                    output: '',
+                    title,
+                    metadata: sessionId ? { sessionId } : {},
+                    time: { start: 1, end: 2 },
+                },
+            };
+        }
+        return {
+            ...base,
             state: {
-                status: 'completed',
-                input: { subagent_type: 'general' },
-                output: '',
-                title: 'Classify pending changes',
-                metadata: { sessionId: 'ses_child' },
-                time: { start: 1, end: 2 },
+                status,
+                input,
+                title,
+                metadata: sessionId ? { sessionId } : {},
+                time: { start: 1 },
             },
         };
-        expect(formatTaskToolTitle(part)).toMatchInlineSnapshot(`"┣ general **Classify pending changes**"`);
+    }
+    test('uses the running task title when OpenAI omits the description', () => {
+        expect(formatTaskToolTitle(taskPart({
+            status: 'running',
+            input: { subagent_type: 'general' },
+            title: 'Classify pending changes',
+            sessionId: 'ses_child',
+        }))).toMatchInlineSnapshot(`"┣ general **Classify pending changes**"`);
+    });
+    test('prefers input description on running parts', () => {
+        expect(formatTaskToolTitle(taskPart({
+            status: 'running',
+            input: { description: 'inspect repo', subagent_type: 'explore' },
+            title: 'ignored title',
+            sessionId: 'ses_child',
+        }))).toMatchInlineSnapshot(`"┣ explore **inspect repo**"`);
+    });
+    test('does not format completed parts so Discord does not post the line at the end', () => {
+        expect(formatTaskToolTitle(taskPart({
+            status: 'completed',
+            input: { subagent_type: 'general' },
+            title: 'Classify pending changes',
+            sessionId: 'ses_child',
+        }))).toBe('');
+    });
+    test('shows queued task calls before the child session exists', () => {
+        expect(formatTaskToolTitle(taskPart({
+            status: 'running',
+            input: {
+                description: 'audit customer pages',
+                subagent_type: 'general',
+            },
+        }))).toMatchInlineSnapshot(`"┣ general **audit customer pages**"`);
     });
 });
 describe('formatBashToolTitle', () => {

package/dist/oauth-rotation-shared.js

@@ -1,3 +1,13 @@
+/**
+ * LEGACY. Superseded by @subrouter/opencode, registered alongside the kimaki
+ * plugin in opencode.ts. This whole rotation path only cycles accounts inside
+ * one provider; subrouter also fails over to a different provider when every
+ * account of one is exhausted.
+ *
+ * Kept because opencode ships no Claude Pro/Max auth of its own, so deleting
+ * it would strand anyone still picking `anthropic/*` directly. To move to
+ * subrouter, log in again through /login and pick Subrouter.
+ */
 /**
  * Shared utilities for multi-provider OAuth account rotation.
  * Used by both anthropic-auth-state.ts and openai-auth-state.ts to avoid

package/dist/openai-auth-plugin.js

@@ -1,3 +1,4 @@
+// LEGACY rotation, superseded by @subrouter/opencode. See oauth-rotation-shared.ts.
 /**
  * OpenAI OAuth rotation plugin for OpenCode.
  *

package/dist/openai-auth-state.js

@@ -1,3 +1,4 @@
+// LEGACY rotation, superseded by @subrouter/opencode. See oauth-rotation-shared.ts.
 /**
  * OpenAI OAuth account store and rotation.
  * Mirrors anthropic-auth-state.ts but for OpenAI/Codex OAuth accounts.

package/dist/opencode-command.test.js

@@ -1,5 +1,6 @@
 // Regression tests for Windows OpenCode command resolution and spawn args.
 import fs from 'node:fs';
+import { createRequire } from 'node:module';
 import os from 'node:os';
 import path from 'node:path';
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
@@ -26,6 +27,65 @@ describe('selectResolvedCommand', () => {
         })).toBe('/usr/local/bin/opencode');
     });
 });
+describe('buildOpencodeServeArgs', () => {
+    test('always passes --hostname so opencode.json cannot bind 0.0.0.0', async () => {
+        const { buildOpencodeServeArgs } = await import('./opencode.js');
+        expect(buildOpencodeServeArgs({ port: 4096 })).toEqual([
+            'serve',
+            '--port',
+            '4096',
+            '--hostname',
+            '127.0.0.1',
+            '--print-logs',
+            '--log-level',
+            'WARN',
+        ]);
+    });
+    test('passes --hostname when set', async () => {
+        const { buildOpencodeServeArgs } = await import('./opencode.js');
+        expect(buildOpencodeServeArgs({ port: 4096, hostname: '0.0.0.0' })).toEqual([
+            'serve',
+            '--port',
+            '4096',
+            '--hostname',
+            '0.0.0.0',
+            '--print-logs',
+            '--log-level',
+            'WARN',
+        ]);
+    });
+});
+describe('published runtime artifacts', () => {
+    test('lists @subrouter/opencode as a runtime dependency', () => {
+        const pkg = JSON.parse(fs.readFileSync(path.join(import.meta.dirname, '../package.json'), 'utf8'));
+        expect(pkg.dependencies?.['@subrouter/opencode']).toMatch(/^(workspace:\^|\^)/);
+    });
+});
+describe('resolveSubrouterPluginSpec', () => {
+    test('uses npm package identity in production for OpenCode deduplication', async () => {
+        const { resolveSubrouterPluginSpec } = await import('./opencode.js');
+        const require = createRequire(import.meta.url);
+        const packageJsonPath = require.resolve('@subrouter/opencode/package.json');
+        const version = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8')).version;
+        expect(resolveSubrouterPluginSpec({ isDev: false })).toBe(`@subrouter/opencode@${version}`);
+    });
+    test('loads workspace source directly in development', async () => {
+        const { resolveSubrouterPluginSpec } = await import('./opencode.js');
+        expect(resolveSubrouterPluginSpec({ isDev: true })).toMatch(/^file:.*\/subrouter\/opencode\/dist\/index\.js$/);
+    });
+});
+describe('publicOpencodeBindRequiresPassword', () => {
+    test('allows loopback without a password', async () => {
+        const { publicOpencodeBindRequiresPassword } = await import('./opencode.js');
+        expect(publicOpencodeBindRequiresPassword({ hostname: null })).toBe(false);
+        expect(publicOpencodeBindRequiresPassword({ hostname: '127.0.0.1' })).toBe(false);
+        expect(publicOpencodeBindRequiresPassword({ hostname: 'localhost' })).toBe(false);
+    });
+    test('requires a password for 0.0.0.0', async () => {
+        const { publicOpencodeBindRequiresPassword } = await import('./opencode.js');
+        expect(publicOpencodeBindRequiresPassword({ hostname: '0.0.0.0' })).toBe(true);
+    });
+});
 describe('getSpawnCommandAndArgs', () => {
     test('wraps windows cmd shims through cmd.exe without double-quoting by node', () => {
         expect(getSpawnCommandAndArgs({

package/dist/opencode.js

@@ -40,13 +40,26 @@ import net from 'node:net';
 import os from 'node:os';
 import path from 'node:path';
 import readline from 'node:readline';
-import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 import { createOpencodeClient, } from '@opencode-ai/sdk/v2';
 import { restartGlobalEventListener, waitForGlobalEventListener, } from './session-handler/global-event-listener.js';
-import { getDataDir, getLockPort, getRestrictExternalDirectories, } from './config.js';
+import { getDataDir, getLockPort, getRestrictExternalDirectories, getOpencodeHostname, getOpencodePort, } from './config.js';
 import { store } from './store.js';
 import { getHranaUrl } from './hrana-server.js';
+export function resolveSubrouterPluginSpec({ isDev }) {
+    const require = createRequire(import.meta.url);
+    const entry = require.resolve('@subrouter/opencode');
+    if (isDev)
+        return pathToFileURL(entry).href;
+    const packageJsonPath = require.resolve('@subrouter/opencode/package.json');
+    const version = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8')).version;
+    if (typeof version !== 'string' || !version) {
+        throw new Error(`Missing @subrouter/opencode version in ${packageJsonPath}`);
+    }
+    return `@subrouter/opencode@${version}`;
+}
 import * as errore from 'errore';
 import { createLogger, LogPrefix } from './logger.js';
 import { notifyError } from './sentry.js';
@@ -66,6 +79,26 @@ export function getOpencodeServerAuthHeaders() {
     const encoded = Buffer.from(`${username}:${serverPassword}`).toString('base64');
     return { Authorization: `Basic ${encoded}` };
 }
+const LOOPBACK_HOSTNAMES = new Set(['127.0.0.1', 'localhost', '::1']);
+export function publicOpencodeBindRequiresPassword({ hostname, }) {
+    if (!hostname)
+        return false;
+    return !LOOPBACK_HOSTNAMES.has(hostname);
+}
+// Always pass --hostname so opencode.json server.hostname / mdns cannot bind 0.0.0.0.
+const DEFAULT_OPENCODE_HOSTNAME = '127.0.0.1';
+export function buildOpencodeServeArgs({ port, hostname, }) {
+    return [
+        'serve',
+        '--port',
+        port.toString(),
+        '--hostname',
+        hostname || DEFAULT_OPENCODE_HOSTNAME,
+        '--print-logs',
+        '--log-level',
+        'WARN',
+    ];
+}
 // Tracks directories that have been initialized, to avoid repeated log spam
 // from the external sync polling loop.
 const initializedDirectories = new Set();
@@ -89,6 +122,7 @@ export async function requestHealthcheck({ url, timeoutMs = 2000, }) {
             method: 'GET',
             headers: {
                 connection: 'close',
+                ...getOpencodeServerAuthHeaders(),
             },
         }, (res) => {
             const chunks = [];
@@ -473,15 +507,17 @@ async function ensureSingleServer({ directory, } = {}) {
 }
 async function startSingleServer({ directory, } = {}) {
     ensureProcessCleanupHandlersRegistered();
-    const port = await getOpenPort();
-    const serveArgs = [
-        'serve',
-        '--port',
-        port.toString(),
-        '--print-logs',
-        '--log-level',
-        'WARN',
-    ];
+    const configuredPort = getOpencodePort();
+    const port = configuredPort ?? (await getOpenPort());
+    const hostname = getOpencodeHostname() ?? DEFAULT_OPENCODE_HOSTNAME;
+    if (publicOpencodeBindRequiresPassword({ hostname }) &&
+        !process.env.OPENCODE_SERVER_PASSWORD) {
+        return new ServerStartError({
+            port,
+            reason: `OPENCODE_SERVER_PASSWORD is required when --opencode-hostname is ${hostname}`,
+        });
+    }
+    const serveArgs = buildOpencodeServeArgs({ port, hostname });
     const { command: spawnCommand, args: spawnArgs, windowsVerbatimArguments, } = getSpawnCommandAndArgs({
         resolvedCommand: resolveOpencodeCommand(),
         baseArgs: serveArgs,
@@ -552,6 +588,9 @@ async function startSingleServer({ directory, } = {}) {
         formatter: false,
         plugin: [
             new URL(isDev ? './kimaki-opencode-plugin.ts' : './kimaki-opencode-plugin.js', import.meta.url).href,
+            // npm identity lets opencode dedupe a user-installed copy by package
+            // name. Development still loads this workspace's built package directly.
+            resolveSubrouterPluginSpec({ isDev }),
         ],
         permission: {
             edit: 'allow',
@@ -639,6 +678,8 @@ async function startSingleServer({ directory, } = {}) {
             OPENCODE_CONFIG: opencodeConfigPath,
             OPENCODE_PORT: port.toString(),
             KIMAKI: '1',
+            // The browser is not on this machine, so no localhost callback fires.
+            SUBROUTER_MANUAL_OAUTH: '1',
             OPENCODE_EXPERIMENTAL_WORKSPACES: 'true',
             OPENCODE_ENABLE_EXA: '1',
             KIMAKI_DATA_DIR: getDataDir(),
@@ -661,7 +702,7 @@ async function startSingleServer({ directory, } = {}) {
     const logBuffer = [];
     const startupStderrTail = [];
     let serverReady = false;
-    logBuffer.push(`Spawned opencode serve --port ${port} (pid: ${serverProcess.pid})`);
+    logBuffer.push(`Spawned opencode ${serveArgs.join(' ')} (pid: ${serverProcess.pid})`);
     const stdoutReader = subscribeToProcessLogStream({
         stream: serverProcess.stdout,
         onLine: (line) => {

package/dist/question-abort-clears-dropdown.e2e.test.js

@@ -0,0 +1,89 @@
+// E2e test: aborting a run must kill the pending question dropdown.
+// Questions have no TTL, so abort is the only thing that clears them while the
+// thread stays alive. Without this, a stale dropdown keeps accepting clicks and
+// answers a question whose run is already dead.
+import { describe, test, expect } from 'vitest';
+import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
+import { waitForBotMessageContaining } from './test-utils.js';
+import { pendingQuestionContexts } from './commands/ask-question.js';
+import { getRuntime } from './session-handler/thread-session-runtime.js';
+const TEXT_CHANNEL_ID = '200000000000001031';
+describe('abort clears pending question dropdown', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-question-abort',
+        dirName: 'qa-question-abort',
+        username: 'question-abort-tester',
+    });
+    test('dropdown stops accepting answers after abort', async () => {
+        const marker = 'QUESTION_SELECT_QUEUE_MARKER abort-test';
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: marker,
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 8_000,
+            predicate: (t) => {
+                return t.name === marker;
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        const questionMessages = await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: 'How to proceed?',
+            timeout: 12_000,
+        });
+        const questionMsg = questionMessages.find((message) => {
+            return message.content.includes('How to proceed?');
+        });
+        if (!questionMsg) {
+            throw new Error('Expected question message');
+        }
+        const pendingEntry = [...pendingQuestionContexts.entries()].find(([, context]) => {
+            return context.thread.id === thread.id;
+        });
+        if (!pendingEntry) {
+            throw new Error('Expected pending question context');
+        }
+        const contextHash = pendingEntry[0];
+        const runtime = getRuntime(thread.id);
+        if (!runtime) {
+            throw new Error('Expected runtime for question abort test');
+        }
+        runtime.abortActiveRun('test-question-abort');
+        // Click the now-dead dropdown. The answer echo must never appear.
+        const interaction = await th.user(TEST_USER_ID).selectMenu({
+            messageId: questionMsg.id,
+            customId: `ask_question:${contextHash}:0`,
+            values: ['0'],
+        });
+        await th.waitForInteractionAck({
+            interactionId: interaction.id,
+            timeout: 8_000,
+        });
+        for (let i = 0; i < 10; i++) {
+            const messages = await th.getMessages();
+            const answered = messages.find((message) => {
+                return message.content.includes('» **question-abort-tester:** Alpha');
+            });
+            if (answered) {
+                throw new Error('Dropdown was still answerable after abort');
+            }
+            await new Promise((resolve) => {
+                setTimeout(resolve, 20);
+            });
+        }
+        const timeline = await th.text({ showInteractions: true });
+        expect(timeline).toMatchInlineSnapshot(`
+        "--- from: user (question-abort-tester)
+        QUESTION_SELECT_QUEUE_MARKER abort-test
+        --- from: assistant (TestBot)
+        *using deterministic-provider/deterministic-v2*
+        **Select action**
+        How to proceed?
+        [user selects dropdown: 0]
+        This question has expired. Please ask the AI again."
+      `);
+        expect(pendingQuestionContexts.size).toBe(0);
+    }, 20_000);
+});

package/dist/question-text-before-dropdown.e2e.test.js

@@ -0,0 +1,52 @@
+// E2e: text that precedes a question tool must post before the dropdown.
+// OpenCode can emit question.asked before the text part's time.end; Kimaki
+// must wait so the plan is not hidden under the question UI.
+import { describe, test, expect } from 'vitest';
+import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
+import { waitForBotMessageContaining } from './test-utils.js';
+const TEXT_CHANNEL_ID = '200000000000001042';
+describe('question text before dropdown', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-question-text-order',
+        dirName: 'qa-question-text-order',
+        username: 'question-text-tester',
+    });
+    test('posts plan text before the question dropdown', async () => {
+        const marker = 'QUESTION_AFTER_TEXT_MARKER';
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: marker,
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 8_000,
+            predicate: (t) => {
+                return t.name === marker;
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: 'What next?',
+            timeout: 8_000,
+        });
+        expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (question-text-tester)
+        QUESTION_AFTER_TEXT_MARKER
+        --- from: assistant (TestBot)
+        *using deterministic-provider/deterministic-v2*
+        ⬥ PLAN_TEXT_BEFORE_QUESTION
+        **Next step**
+        What next?"
+      `);
+        const messages = await th.getMessages();
+        const planIndex = messages.findIndex((message) => {
+            return message.content.includes('PLAN_TEXT_BEFORE_QUESTION');
+        });
+        const questionIndex = messages.findIndex((message) => {
+            return message.content.includes('What next?');
+        });
+        expect(planIndex).toBeGreaterThanOrEqual(0);
+        expect(questionIndex).toBeGreaterThan(planIndex);
+    }, 15_000);
+});

package/dist/queue-advanced-abort.e2e.test.js

@@ -157,7 +157,7 @@ e2eTest('queue advanced: abort and retry', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/deterministic-v2*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>
         --- from: user (queue-advanced-tester)
         SLOW_ABORT_MARKER run long response"
       `);