@otto-assistant/otto 0.1.2 → 0.7.15

package/dist/plugin-logger.js

@@ -0,0 +1,68 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import util from 'node:util';
+import { sanitizeSensitiveText, sanitizeUnknownValue } from './privacy-sanitizer.js';
+let pluginLogFilePath = null;
+export function setPluginLogFilePath(dataDir) {
+    pluginLogFilePath = path.join(dataDir, 'otto.log');
+}
+function formatArg(arg) {
+    if (typeof arg === 'string') {
+        return sanitizeSensitiveText(arg, { redactPaths: false });
+    }
+    const safeArg = sanitizeUnknownValue(arg, { redactPaths: false });
+    return util.inspect(safeArg, { colors: false, depth: 4 });
+}
+export function formatPluginErrorWithStack(error) {
+    if (error instanceof Error) {
+        return sanitizeSensitiveText(error.stack ?? `${error.name}: ${error.message}`, { redactPaths: false });
+    }
+    if (typeof error === 'string') {
+        return sanitizeSensitiveText(error, { redactPaths: false });
+    }
+    const safeError = sanitizeUnknownValue(error, { redactPaths: false });
+    return sanitizeSensitiveText(util.inspect(safeError, { colors: false, depth: 4 }), {
+        redactPaths: false,
+    });
+}
+function writeToFile(level, prefix, args) {
+    if (!pluginLogFilePath) {
+        return;
+    }
+    const timestamp = new Date().toISOString();
+    const message = `[${timestamp}] [${level}] [${prefix}] ${args.map(formatArg).join(' ')}\n`;
+    try {
+        fs.appendFileSync(pluginLogFilePath, message);
+    }
+    catch {
+        // Plugin logging must never break the OpenCode plugin process.
+    }
+}
+export function createPluginLogger(prefix) {
+    return {
+        log: (...args) => {
+            writeToFile('LOG', prefix, args);
+        },
+        info: (...args) => {
+            writeToFile('INFO', prefix, args);
+        },
+        warn: (...args) => {
+            writeToFile('WARN', prefix, args);
+        },
+        error: (...args) => {
+            writeToFile('ERROR', prefix, args);
+        },
+        debug: (...args) => {
+            writeToFile('DEBUG', prefix, args);
+        },
+    };
+}
+// Append a session ID marker at the end of a toast message so the bot-side
+// handleTuiToast can route the toast to the correct Discord thread.
+// Without this marker the toast is silently dropped.
+export function appendToastSessionMarker({ message, sessionId, }) {
+    if (!sessionId) {
+        return message;
+    }
+    return `${message} ${sessionId}`;
+}

package/dist/privacy-sanitizer.js

@@ -0,0 +1,105 @@
+// Sensitive data redaction helpers for logs and telemetry payloads.
+// Redacts common secrets, identifiers, emails, and can optionally redact paths.
+const CORE_SENSITIVE_REPLACEMENTS = [
+    {
+        pattern: /\bBearer\s+[A-Za-z0-9._-]{10,}\b/gi,
+        replacement: 'Bearer [REDACTED]',
+    },
+    {
+        pattern: /\bsk-[A-Za-z0-9]{16,}\b/g,
+        replacement: '[REDACTED_OPENAI_KEY]',
+    },
+    {
+        pattern: /\bAIza[0-9A-Za-z_-]{20,}\b/g,
+        replacement: '[REDACTED_GOOGLE_KEY]',
+    },
+    {
+        pattern: /\bgh[pousr]_[A-Za-z0-9]{20,}\b/g,
+        replacement: '[REDACTED_GITHUB_TOKEN]',
+    },
+    {
+        pattern: /([?&](?:token|api[_-]?key|key|secret|password|authorization)=)[^&\s]+/gi,
+        replacement: '$1[REDACTED]',
+    },
+    {
+        pattern: /(\b(?:token|api[_-]?key|secret|password|authorization)\b\s*[:=]\s*")([^"]+)(")/gi,
+        replacement: '$1[REDACTED]$3',
+    },
+    {
+        pattern: /(\b(?:token|api[_-]?key|secret|password|authorization)\b\s*[:=]\s*)([^\s,;]+)/gi,
+        replacement: '$1[REDACTED]',
+    },
+];
+const PATH_REPLACEMENTS = [
+    {
+        pattern: /\/(?:Users|home)\/[^/\s]+\/[^\s'"`)]*/g,
+        replacement: '[REDACTED_PATH]',
+    },
+    {
+        pattern: /[A-Za-z]:\\[^\s'"`)]*/g,
+        replacement: '[REDACTED_PATH]',
+    },
+];
+export function sanitizeSensitiveText(value, { redactPaths = false } = {}) {
+    const replacements = redactPaths
+        ? [...CORE_SENSITIVE_REPLACEMENTS, ...PATH_REPLACEMENTS]
+        : CORE_SENSITIVE_REPLACEMENTS;
+    return replacements.reduce((current, entry) => {
+        return current.replace(entry.pattern, entry.replacement);
+    }, value);
+}
+export function sanitizeUnknownValue(value, { depth = 0, seen = new WeakSet(), redactPaths = false, } = {}) {
+    if (depth > 8) {
+        return '[REDACTED_DEPTH_LIMIT]';
+    }
+    if (typeof value === 'string') {
+        return sanitizeSensitiveText(value, { redactPaths });
+    }
+    if (typeof value === 'number' ||
+        typeof value === 'boolean' ||
+        value === null ||
+        value === undefined) {
+        return value;
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (value instanceof Error) {
+        const sanitizedStack = value.stack
+            ? sanitizeSensitiveText(value.stack, { redactPaths })
+            : undefined;
+        return {
+            name: value.name,
+            message: sanitizeSensitiveText(value.message, { redactPaths }),
+            stack: sanitizedStack,
+            cause: sanitizeUnknownValue(value.cause, {
+                depth: depth + 1,
+                seen,
+                redactPaths,
+            }),
+        };
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => {
+            return sanitizeUnknownValue(item, { depth: depth + 1, seen, redactPaths });
+        });
+    }
+    if (typeof value === 'object') {
+        if (seen.has(value)) {
+            return '[REDACTED_CIRCULAR]';
+        }
+        seen.add(value);
+        const sanitizedEntries = Object.entries(value).map(([key, entryValue]) => {
+            return [
+                key,
+                sanitizeUnknownValue(entryValue, {
+                    depth: depth + 1,
+                    seen,
+                    redactPaths,
+                }),
+            ];
+        });
+        return Object.fromEntries(sanitizedEntries);
+    }
+    return sanitizeSensitiveText(String(value), { redactPaths });
+}

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

@@ -0,0 +1,293 @@
+// E2e tests for abort, model-switch, and retry scenarios.
+// Split from thread-queue-advanced.e2e.test.ts for parallelization.
+import { describe, test, expect } from 'vitest';
+import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
+import { getRuntime, } from './session-handler/thread-session-runtime.js';
+import { getThreadState } from './session-handler/thread-runtime-state.js';
+import { setSessionModel } from './database.js';
+import { waitForFooterMessage, waitForBotMessageContaining, waitForBotReplyAfterUserMessage, } from './test-utils.js';
+const TEXT_CHANNEL_ID = '200000000000001003';
+const e2eTest = describe;
+e2eTest('queue advanced: abort and retry', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-abort-e2e',
+        dirName: 'qa-abort-e2e',
+        username: 'queue-advanced-tester',
+    });
+    test('slow tool call (sleep) gets aborted by explicit abort, then queue continues', async () => {
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: oscar',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: oscar';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        const firstReply = await th.waitForBotReply({ timeout: 4_000 });
+        expect(firstReply.content.trim().length).toBeGreaterThan(0);
+        // Wait for the first completion footer so it lands in a deterministic position
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 4_000,
+        });
+        const before = await th.getMessages();
+        const beforeBotCount = before.filter((m) => {
+            return m.author.id === ctx.discord.botUserId;
+        }).length;
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+        });
+        // The matcher emits "starting sleep 100" text before the long delay.
+        // Wait for it to land in Discord BEFORE aborting so the message is in a
+        // deterministic position and the abort produces no further stray messages.
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'starting sleep',
+            afterUserMessageIncludes: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+            timeout: 4_000,
+        });
+        const runtime = getRuntime(thread.id);
+        expect(runtime).toBeDefined();
+        if (!runtime) {
+            throw new Error('Expected runtime to exist for explicit-abort test');
+        }
+        runtime.abortActiveRun('test-explicit-abort');
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: papa',
+        });
+        const after = await waitForBotReplyAfterUserMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            userMessageIncludes: 'papa',
+            timeout: 8_000,
+        });
+        const afterBotMessages = after.filter((m) => {
+            return m.author.id === ctx.discord.botUserId;
+        });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 8_000,
+            afterMessageIncludes: 'papa',
+            afterAuthorId: TEST_USER_ID,
+        });
+        // Assert ordering invariants instead of exact snapshot — the papa reply
+        // and footer can interleave non-deterministically.
+        const timeline = await th.text();
+        expect(timeline).toContain('Reply with exactly: oscar');
+        expect(timeline).toContain('PLUGIN_TIMEOUT_SLEEP_MARKER');
+        expect(timeline).toContain('⬥ starting sleep 100');
+        expect(timeline).toContain('Reply with exactly: papa');
+        expect(timeline).toContain('*project ⋅ main ⋅');
+        // oscar comes before the sleep marker, sleep before papa
+        const oscarIdx = timeline.indexOf('oscar');
+        const sleepIdx = timeline.indexOf('PLUGIN_TIMEOUT_SLEEP_MARKER');
+        const papaIdx = timeline.indexOf('papa');
+        expect(oscarIdx).toBeLessThan(sleepIdx);
+        expect(sleepIdx).toBeLessThan(papaIdx);
+        expect(afterBotMessages.length).toBeGreaterThanOrEqual(beforeBotCount + 1);
+        const sleepToolIndex = after.findIndex((m) => {
+            return (m.author.id === TEST_USER_ID &&
+                m.content.includes('PLUGIN_TIMEOUT_SLEEP_MARKER'));
+        });
+        expect(sleepToolIndex).toBeGreaterThan(-1);
+        const userPapaIndex = after.findIndex((m) => {
+            return m.author.id === TEST_USER_ID && m.content.includes('papa');
+        });
+        expect(userPapaIndex).toBeGreaterThan(-1);
+        expect(sleepToolIndex).toBeLessThan(userPapaIndex);
+        const lastBotIndex = after.findLastIndex((m) => {
+            return m.author.id === ctx.discord.botUserId;
+        });
+        expect(userPapaIndex).toBeLessThan(lastBotIndex);
+    }, 12_000);
+    test('explicit abort emits MessageAbortedError and does not emit footer', async () => {
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: abort-no-footer-setup',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: abort-no-footer-setup';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        await th.waitForBotReply({ timeout: 4_000 });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: '⋅',
+            timeout: 4_000,
+        });
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'SLOW_ABORT_MARKER run long response',
+        });
+        const runtime = getRuntime(thread.id);
+        expect(runtime).toBeDefined();
+        if (!runtime) {
+            throw new Error('Expected runtime to exist for abort no-footer test');
+        }
+        const beforeAbortMessages = await th.getMessages();
+        const baselineCount = beforeAbortMessages.length;
+        runtime.abortActiveRun('test-no-footer-on-abort');
+        for (let i = 0; i < 10; i++) {
+            await new Promise((resolve) => {
+                setTimeout(resolve, 20);
+            });
+            const msgs = await th.getMessages();
+            const newMsgs = msgs.slice(baselineCount);
+            const hasFooter = newMsgs.some((m) => {
+                return m.author.id === ctx.discord.botUserId
+                    && m.content.startsWith('*')
+                    && m.content.includes('⋅');
+            });
+            expect(hasFooter).toBe(false);
+        }
+        expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (queue-advanced-tester)
+        Reply with exactly: abort-no-footer-setup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        --- from: user (queue-advanced-tester)
+        SLOW_ABORT_MARKER run long response"
+      `);
+    }, 10_000);
+    test.skip('explicit abort stale-idle window: follow-up prompt still gets assistant text', async () => {
+        const setupPrompt = 'Reply with exactly: race-setup-1';
+        const raceFinalPrompt = 'Reply with exactly: race-final-1';
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: setupPrompt,
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === setupPrompt;
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        const setupReply = await th.waitForBotReply({ timeout: 4_000 });
+        expect(setupReply.content.trim().length).toBeGreaterThan(0);
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'SLOW_ABORT_MARKER run long response',
+        });
+        const runtime = getRuntime(thread.id);
+        expect(runtime).toBeDefined();
+        if (!runtime) {
+            throw new Error('Expected runtime to exist for race abort scenario');
+        }
+        runtime.abortActiveRun('test-race-abort');
+        await th.user(TEST_USER_ID).sendMessage({
+            content: raceFinalPrompt,
+        });
+        await waitForBotReplyAfterUserMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            userMessageIncludes: raceFinalPrompt,
+            timeout: 4_000,
+        });
+    }, 8_000);
+    test('model switch mid-session aborts and restarts from same session history', async () => {
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: retry-setup',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: retry-setup';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        const firstReply = await th.waitForBotReply({ timeout: 4_000 });
+        expect(firstReply.content.trim().length).toBeGreaterThan(0);
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'starting sleep',
+            afterUserMessageIncludes: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+            timeout: 4_000,
+        });
+        const sessionId = getThreadState(thread.id)?.sessionId;
+        expect(sessionId).toBeDefined();
+        if (!sessionId) {
+            throw new Error('Expected active session id for model switch test');
+        }
+        await setSessionModel({
+            sessionId,
+            modelId: 'deterministic-provider/deterministic-v3',
+            variant: null,
+        });
+        const runtime = getRuntime(thread.id);
+        expect(runtime).toBeDefined();
+        if (!runtime) {
+            throw new Error('Expected runtime to exist for model switch test');
+        }
+        const retried = await runtime.retryLastUserPrompt();
+        expect(retried).toBe(true);
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: model-switch-followup',
+        });
+        await waitForBotReplyAfterUserMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            userMessageIncludes: 'model-switch-followup',
+            timeout: 4_000,
+        });
+        // Wait for potential footer to arrive (race between step-finish interrupt
+        // and model switch settling means footer may or may not appear).
+        await new Promise((resolve) => {
+            setTimeout(resolve, 200);
+        });
+        const text = await th.text();
+        // The follow-up reply ("ok") must be present with deterministic-v3
+        expect(text).toContain('Reply with exactly: model-switch-followup');
+        expect(text).toContain('⬥ ok');
+        // The old sleep text should be visible from the first turn
+        expect(text).toContain('starting sleep 100');
+    }, 10_000);
+    test('abortActiveRun settles correctly during long-running request', async () => {
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: force-abort-setup',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: force-abort-setup';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        const setupReply = await th.waitForBotReply({ timeout: 4_000 });
+        expect(setupReply.content.trim().length).toBeGreaterThan(0);
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'SLOW_ABORT_MARKER run long response',
+        });
+        const runtime = getRuntime(thread.id);
+        expect(runtime).toBeDefined();
+        if (!runtime) {
+            throw new Error('Expected runtime to exist for forced-abort test');
+        }
+        runtime.abortActiveRun('force-abort-test');
+        expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (queue-advanced-tester)
+        Reply with exactly: force-abort-setup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        --- from: user (queue-advanced-tester)
+        SLOW_ABORT_MARKER run long response"
+      `);
+    }, 10_000);
+});

package/dist/queue-advanced-action-buttons.e2e.test.js

@@ -0,0 +1,206 @@
+// E2e regression test for action button click continuation in thread sessions.
+// Reproduces the bug where button click interaction acks but the session does not continue.
+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 = '200000000000001006';
+async function waitForPendingActionButtons({ threadId, timeoutMs, }) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const entry = [...pendingActionButtonContexts.entries()].find(([, context]) => {
+            return context.thread.id === threadId && Boolean(context.messageId);
+        });
+        if (entry) {
+            const [contextHash, context] = entry;
+            if (context.messageId) {
+                return { contextHash, messageId: context.messageId };
+            }
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, 100);
+        });
+    }
+    throw new Error('Timed out waiting for pending action buttons context');
+}
+async function waitForNoPendingActionButtons({ threadId, timeoutMs, }) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const stillPending = [...pendingActionButtonContexts.values()].some((context) => {
+            return context.thread.id === threadId;
+        });
+        if (!stillPending) {
+            return;
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, 100);
+        });
+    }
+    throw new Error('Timed out waiting for action buttons cleanup');
+}
+describe('queue advanced: action buttons', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-action-buttons-e2e',
+        dirName: 'qa-action-buttons-e2e',
+        username: 'queue-action-tester',
+    });
+    test('button click should continue the session with a follow-up assistant reply', async () => {
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: action-button-setup',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: action-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,
+        });
+        const currentSessionId = await getThreadSession(thread.id);
+        if (!currentSessionId) {
+            throw new Error('Expected thread session id before showing action buttons');
+        }
+        const channel = await ctx.botClient.channels.fetch(thread.id);
+        if (!channel || !channel.isThread()) {
+            throw new Error('Expected Discord thread channel for action button test');
+        }
+        await showActionButtons({
+            thread: channel,
+            sessionId: currentSessionId,
+            directory: ctx.directories.projectDirectory,
+            buttons: [{ label: 'Continue action-buttons flow', color: 'green' }],
+        });
+        const action = await waitForPendingActionButtons({
+            threadId: thread.id,
+            timeoutMs: 12_000,
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'Action Required',
+            timeout: 12_000,
+        });
+        const interaction = await th.user(TEST_USER_ID).clickButton({
+            messageId: action.messageId,
+            customId: `action_button:${action.contextHash}:0`,
+        });
+        await th.waitForInteractionAck({
+            interactionId: interaction.id,
+            timeout: 4_000,
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: 'action-buttons-click-continued',
+            timeout: 12_000,
+        });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 12_000,
+            afterMessageIncludes: 'action-buttons-click-continued',
+            afterAuthorId: ctx.discord.botUserId,
+        });
+        const timeline = await th.text({ showInteractions: true });
+        expect(timeline).toMatchInlineSnapshot(`
+        "--- from: user (queue-action-tester)
+        Reply with exactly: action-button-setup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        **Action Required**
+        _Selected: Continue action-buttons flow_
+        [user clicks button]
+        ⬥ action-buttons-click-continued
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `);
+        expect(timeline).toContain('action-buttons-click-continued');
+    }, 20_000);
+    test('manual thread message dismisses pending action buttons', async () => {
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: action-button-dismiss-setup',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: action-button-dismiss-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,
+        });
+        const currentSessionId = await getThreadSession(thread.id);
+        if (!currentSessionId) {
+            throw new Error('Expected thread session id before showing action buttons');
+        }
+        const channel = await ctx.botClient.channels.fetch(thread.id);
+        if (!channel || !channel.isThread()) {
+            throw new Error('Expected Discord thread channel for action button test');
+        }
+        await showActionButtons({
+            thread: channel,
+            sessionId: currentSessionId,
+            directory: ctx.directories.projectDirectory,
+            buttons: [{ label: 'Dismiss me', color: 'white' }],
+        });
+        await waitForPendingActionButtons({
+            threadId: thread.id,
+            timeoutMs: 4_000,
+        });
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: post-dismiss-user-message',
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: 'Buttons dismissed.',
+            timeout: 4_000,
+        });
+        await waitForNoPendingActionButtons({
+            threadId: thread.id,
+            timeoutMs: 4_000,
+        });
+        const timeline = await th.text({ showInteractions: true });
+        expect(timeline).toMatchInlineSnapshot(`
+        "--- from: user (queue-action-tester)
+        Reply with exactly: action-button-dismiss-setup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        **Action Required**
+        _Buttons dismissed._
+        --- from: user (queue-action-tester)
+        Reply with exactly: post-dismiss-user-message"
+      `);
+        expect(timeline).toContain('_Buttons dismissed._');
+        expect(timeline).toContain('post-dismiss-user-message');
+    }, 20_000);
+});