discoclaw 0.1.0

package/dist/discord-followup.test.js

@@ -0,0 +1,677 @@
+import { describe, expect, it, vi, afterEach } from 'vitest';
+import { ChannelType } from 'discord.js';
+import { createMessageCreateHandler } from './discord.js';
+import { hasQueryAction, QUERY_ACTION_TYPES } from './discord/action-categories.js';
+import { inFlightReplyCount, _resetForTest as resetInFlight } from './discord/inflight-replies.js';
+import * as abortRegistry from './discord/abort-registry.js';
+import { _resetDestructiveConfirmationForTest as resetDestructiveConfirm } from './discord/destructive-confirmation.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeQueue() {
+    return {
+        run: vi.fn(async (_key, fn) => fn()),
+    };
+}
+function makeMsg(overrides = {}) {
+    const replyObj = { edit: vi.fn(async () => { }), delete: vi.fn(async () => { }) };
+    const guild = makeMockGuild([
+        { id: 'cat1', name: 'Dev', type: ChannelType.GuildCategory },
+        { id: 'ch1', name: 'general', type: ChannelType.GuildText, parentName: 'Dev' },
+    ]);
+    return {
+        author: { id: '123', bot: false, displayName: 'User', username: 'user' },
+        guildId: 'guild',
+        guild,
+        channelId: 'chan',
+        channel: { send: vi.fn(async () => ({ edit: vi.fn(async () => { }), delete: vi.fn(async () => { }) })), isThread: () => false, name: 'general' },
+        content: 'list all channels',
+        reply: vi.fn(async () => replyObj),
+        id: 'msg1',
+        client: {},
+        ...overrides,
+    };
+}
+function makeMockGuild(channels) {
+    const cache = new Map();
+    for (const ch of channels) {
+        cache.set(ch.id, {
+            id: ch.id,
+            name: ch.name,
+            type: ch.type,
+            parent: ch.parentName ? { name: ch.parentName } : null,
+        });
+    }
+    return {
+        channels: {
+            cache: {
+                find: (fn) => {
+                    for (const ch of cache.values())
+                        if (fn(ch))
+                            return ch;
+                    return undefined;
+                },
+                values: () => cache.values(),
+                get size() { return cache.size; },
+            },
+            create: vi.fn(async (opts) => ({ name: opts.name, id: 'new-id' })),
+        },
+    };
+}
+function baseParams(runtimeOverride, overrides = {}) {
+    return {
+        allowUserIds: new Set(['123']),
+        botDisplayName: 'TestBot',
+        runtime: runtimeOverride,
+        sessionManager: { getOrCreate: vi.fn(async () => 'sess') },
+        workspaceCwd: '/tmp',
+        projectCwd: '/tmp',
+        groupsDir: '/tmp',
+        useGroupDirCwd: false,
+        runtimeModel: 'opus',
+        runtimeTools: [],
+        runtimeTimeoutMs: 1000,
+        requireChannelContext: false,
+        autoIndexChannelContext: false,
+        autoJoinThreads: false,
+        useRuntimeSessions: true,
+        discordActionsEnabled: true,
+        discordActionsChannels: true,
+        discordActionsMessaging: false,
+        discordActionsGuild: false,
+        discordActionsModeration: false,
+        discordActionsPolls: false,
+        discordActionsTasks: false,
+        discordActionsBotProfile: false,
+        messageHistoryBudget: 0,
+        summaryEnabled: false,
+        summaryModel: 'haiku',
+        summaryMaxChars: 2000,
+        summaryEveryNTurns: 5,
+        summaryDataDir: '/tmp/summaries',
+        summaryToDurableEnabled: false,
+        shortTermMemoryEnabled: false,
+        shortTermDataDir: '/tmp/shortterm',
+        shortTermMaxEntries: 20,
+        shortTermMaxAgeMs: 21600000,
+        shortTermInjectMaxChars: 1000,
+        durableMemoryEnabled: false,
+        durableDataDir: '/tmp/durable',
+        durableInjectMaxChars: 2000,
+        durableMaxItems: 200,
+        memoryCommandsEnabled: false,
+        actionFollowupDepth: 3,
+        reactionHandlerEnabled: false,
+        reactionRemoveHandlerEnabled: false,
+        reactionMaxAgeMs: 24 * 60 * 60 * 1000,
+        streamStallWarningMs: 0,
+        ...overrides,
+    };
+}
+// ---------------------------------------------------------------------------
+// hasQueryAction unit tests
+// ---------------------------------------------------------------------------
+describe('hasQueryAction', () => {
+    it('returns true when a query action type is present', () => {
+        expect(hasQueryAction(['channelList'])).toBe(true);
+        expect(hasQueryAction(['readMessages', 'sendMessage'])).toBe(true);
+        expect(hasQueryAction(['taskShow'])).toBe(true);
+    });
+    it('returns false when only mutation types are present', () => {
+        expect(hasQueryAction(['channelCreate'])).toBe(false);
+        expect(hasQueryAction(['sendMessage', 'channelDelete'])).toBe(false);
+    });
+    it('returns false for empty list', () => {
+        expect(hasQueryAction([])).toBe(false);
+    });
+});
+describe('QUERY_ACTION_TYPES', () => {
+    it('contains all expected query types', () => {
+        const expected = [
+            'channelList', 'channelInfo', 'threadListArchived',
+            'readMessages', 'fetchMessage', 'listPins',
+            'memberInfo', 'roleInfo', 'searchMessages', 'eventList',
+            'taskList', 'taskShow', 'forgeStatus',
+        ];
+        for (const t of expected) {
+            expect(QUERY_ACTION_TYPES.has(t)).toBe(true);
+        }
+    });
+    it('does not contain mutation types', () => {
+        const mutations = ['channelCreate', 'channelDelete', 'sendMessage', 'taskCreate', 'taskClose'];
+        for (const t of mutations) {
+            expect(QUERY_ACTION_TYPES.has(t)).toBe(false);
+        }
+    });
+    it('contains forgeStatus (forgeStatus returns data the model must synthesize into a reply)', () => {
+        expect(QUERY_ACTION_TYPES.has('forgeStatus')).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// Auto-follow-up integration tests
+// ---------------------------------------------------------------------------
+describe('auto-follow-up for query actions', () => {
+    it('triggers follow-up when a query action (channelList) is present', async () => {
+        let callCount = 0;
+        const runtime = {
+            invoke: vi.fn(async function* () {
+                callCount++;
+                if (callCount === 1) {
+                    // First call: emit a channelList action.
+                    yield { type: 'text_final', text: 'Here are the channels:\n<discord-action>{"type":"channelList"}</discord-action>' };
+                }
+                else {
+                    // Follow-up call: just respond with analysis.
+                    yield { type: 'text_final', text: 'I can see there are 2 channels in the server.' };
+                }
+            }),
+        };
+        const handler = createMessageCreateHandler(baseParams(runtime), makeQueue());
+        await handler(makeMsg());
+        expect(runtime.invoke).toHaveBeenCalledTimes(2);
+        // Second call should have auto-follow-up prompt.
+        const secondPrompt = runtime.invoke.mock.calls[1][0].prompt;
+        expect(secondPrompt).toContain('[Auto-follow-up]');
+        expect(secondPrompt).toContain('Done:');
+    });
+    it('does NOT trigger follow-up for mutation-only actions', async () => {
+        const runtime = {
+            invoke: vi.fn(async function* () {
+                yield { type: 'text_final', text: 'Creating channel:\n<discord-action>{"type":"channelCreate","name":"test"}</discord-action>' };
+            }),
+        };
+        const handler = createMessageCreateHandler(baseParams(runtime), makeQueue());
+        await handler(makeMsg());
+        expect(runtime.invoke).toHaveBeenCalledTimes(1);
+    });
+    it('triggers follow-up when mixed query+mutation actions are present', async () => {
+        let callCount = 0;
+        const runtime = {
+            invoke: vi.fn(async function* () {
+                callCount++;
+                if (callCount === 1) {
+                    yield {
+                        type: 'text_final',
+                        text: 'Listing and creating:\n<discord-action>{"type":"channelList"}</discord-action>\n<discord-action>{"type":"channelCreate","name":"new-ch"}</discord-action>',
+                    };
+                }
+                else {
+                    yield { type: 'text_final', text: 'Done analyzing the channel list.' };
+                }
+            }),
+        };
+        const handler = createMessageCreateHandler(baseParams(runtime), makeQueue());
+        await handler(makeMsg());
+        // Should follow up because channelList (query) was present and succeeded.
+        expect(runtime.invoke).toHaveBeenCalledTimes(2);
+    });
+    it('respects depth limit (no infinite loops)', async () => {
+        // Each invoke produces a channelList action, would loop forever without depth limit.
+        const runtime = {
+            invoke: vi.fn(async function* () {
+                yield { type: 'text_final', text: 'Checking:\n<discord-action>{"type":"channelList"}</discord-action>' };
+            }),
+        };
+        const handler = createMessageCreateHandler(baseParams(runtime, { actionFollowupDepth: 2 }), makeQueue());
+        await handler(makeMsg());
+        // Initial invoke + 2 follow-ups = 3 total.
+        expect(runtime.invoke).toHaveBeenCalledTimes(3);
+    });
+    it('does not follow up when depth is 0 (feature disabled)', async () => {
+        const runtime = {
+            invoke: vi.fn(async function* () {
+                yield { type: 'text_final', text: 'List:\n<discord-action>{"type":"channelList"}</discord-action>' };
+            }),
+        };
+        const handler = createMessageCreateHandler(baseParams(runtime, { actionFollowupDepth: 0 }), makeQueue());
+        await handler(makeMsg());
+        expect(runtime.invoke).toHaveBeenCalledTimes(1);
+    });
+    it('suppresses trivially short follow-up responses', async () => {
+        let callCount = 0;
+        const runtime = {
+            invoke: vi.fn(async function* () {
+                callCount++;
+                if (callCount === 1) {
+                    yield { type: 'text_final', text: 'Listing:\n<discord-action>{"type":"channelList"}</discord-action>' };
+                }
+                else {
+                    // Trivially short response with no actions.
+                    yield { type: 'text_final', text: 'Got it.' };
+                }
+            }),
+        };
+        const msg = makeMsg();
+        const handler = createMessageCreateHandler(baseParams(runtime), makeQueue());
+        await handler(msg);
+        // Should invoke twice (initial + follow-up), but the follow-up message should be deleted.
+        expect(runtime.invoke).toHaveBeenCalledTimes(2);
+        // The follow-up placeholder is created via channel.send, and should have delete() called.
+        const sendResult = await msg.channel.send.mock.results[0]?.value;
+        if (sendResult) {
+            expect(sendResult.delete).toHaveBeenCalled();
+        }
+    });
+    it('does not suppress a substantial follow-up response', async () => {
+        let callCount = 0;
+        const runtime = {
+            invoke: vi.fn(async function* () {
+                callCount++;
+                if (callCount === 1) {
+                    yield { type: 'text_final', text: 'Listing:\n<discord-action>{"type":"channelList"}</discord-action>' };
+                }
+                else {
+                    yield { type: 'text_final', text: 'Based on the channel list, I can see you have a Dev category with a general channel, plus a random channel at the top level.' };
+                }
+            }),
+        };
+        const msg = makeMsg();
+        const handler = createMessageCreateHandler(baseParams(runtime), makeQueue());
+        await handler(msg);
+        expect(runtime.invoke).toHaveBeenCalledTimes(2);
+        // The follow-up message should be edited (not deleted).
+        const sendResult = await msg.channel.send.mock.results[0]?.value;
+        if (sendResult) {
+            expect(sendResult.edit).toHaveBeenCalled();
+            expect(sendResult.delete).not.toHaveBeenCalled();
+        }
+    });
+    it('shows unavailable action types when actions are stripped', async () => {
+        const runtime = {
+            invoke: vi.fn(async function* () {
+                yield { type: 'text_final', text: '<discord-action>{"type":"notARealAction"}</discord-action>' };
+            }),
+        };
+        const msg = makeMsg();
+        const handler = createMessageCreateHandler(baseParams(runtime), makeQueue());
+        await handler(msg);
+        expect(runtime.invoke).toHaveBeenCalledTimes(1);
+        const replyObj = await msg.reply.mock.results[0]?.value;
+        const lastEditContent = replyObj?.edit?.mock?.calls?.[replyObj.edit.mock.calls.length - 1]?.[0]?.content ?? '';
+        expect(lastEditContent).toContain('Ignored unavailable action type:');
+        expect(lastEditContent).toContain('`notARealAction`');
+        expect(replyObj.delete).not.toHaveBeenCalled();
+    });
+    it('follow-up runs inside queue (serialization preserved)', async () => {
+        let callCount = 0;
+        const runtime = {
+            invoke: vi.fn(async function* () {
+                callCount++;
+                if (callCount === 1) {
+                    yield { type: 'text_final', text: 'Listing:\n<discord-action>{"type":"channelList"}</discord-action>' };
+                }
+                else {
+                    yield { type: 'text_final', text: 'Analysis of channels complete with detailed information.' };
+                }
+            }),
+        };
+        const queue = makeQueue();
+        const handler = createMessageCreateHandler(baseParams(runtime), queue);
+        await handler(makeMsg());
+        // Queue.run is called once for the entire message handling (including follow-ups).
+        expect(queue.run).toHaveBeenCalledTimes(1);
+    });
+    it('suppresses sendMessage Done line from posted message but keeps it in follow-up prompt', async () => {
+        let callCount = 0;
+        const runtime = {
+            invoke: vi.fn(async function* () {
+                callCount++;
+                if (callCount === 1) {
+                    // First call: emit a channelList (query) + sendMessage action.
+                    yield {
+                        type: 'text_final',
+                        text: 'Here you go:\n<discord-action>{"type":"channelList"}</discord-action>\n<discord-action>{"type":"sendMessage","channel":"general","content":"hello"}</discord-action>',
+                    };
+                }
+                else {
+                    yield { type: 'text_final', text: 'Analysis complete with enough length to avoid suppression threshold for testing.' };
+                }
+            }),
+        };
+        // Build a guild mock that supports both cache.get() and cache.find() with a sendable channel.
+        const generalCh = {
+            id: 'ch1',
+            name: 'general',
+            type: ChannelType.GuildText,
+            parent: { name: 'Dev' },
+            send: vi.fn(async () => ({})),
+        };
+        const catCh = {
+            id: 'cat1',
+            name: 'Dev',
+            type: ChannelType.GuildCategory,
+            parent: null,
+        };
+        const channelsMap = new Map([
+            ['ch1', generalCh],
+            ['cat1', catCh],
+        ]);
+        const guild = {
+            channels: {
+                cache: {
+                    get: (id) => channelsMap.get(id),
+                    find: (fn) => {
+                        for (const ch of channelsMap.values())
+                            if (fn(ch))
+                                return ch;
+                        return undefined;
+                    },
+                    values: () => channelsMap.values(),
+                    get size() { return channelsMap.size; },
+                },
+                create: vi.fn(async (opts) => ({ name: opts.name, id: 'new-id' })),
+            },
+        };
+        const handler = createMessageCreateHandler(baseParams(runtime, { discordActionsMessaging: true }), makeQueue());
+        const msg = makeMsg({ guild });
+        await handler(msg);
+        expect(runtime.invoke).toHaveBeenCalledTimes(2);
+        // The follow-up prompt should contain the sendMessage Done line (all results unfiltered).
+        const secondPrompt = runtime.invoke.mock.calls[1][0].prompt;
+        expect(secondPrompt).toContain('[Auto-follow-up]');
+        expect(secondPrompt).toContain('Done: Sent message');
+        // The posted message (first reply edit) should NOT contain 'Done: Sent message'.
+        const replyObj = await msg.reply.mock.results[0]?.value;
+        if (replyObj) {
+            const allEditContents = replyObj.edit.mock.calls.map((c) => typeof c[0] === 'string' ? c[0] : c[0]?.content ?? '');
+            const postedContent = allEditContents[allEditContents.length - 1];
+            expect(postedContent).not.toContain('Done: Sent message');
+        }
+    });
+    it('suppresses sendMessage targeting parent forum when in a bead thread', async () => {
+        const runtime = {
+            invoke: vi.fn(async function* () {
+                yield {
+                    type: 'text_final',
+                    text: 'Here is my response.\n<discord-action>{"type":"sendMessage","channel":"forum1","content":"hello"}</discord-action>',
+                };
+            }),
+        };
+        // Build a guild with a forum channel and thread channel in the cache.
+        const forumCh = {
+            id: 'forum1',
+            name: 'beads',
+            type: ChannelType.GuildForum,
+            parent: null,
+            send: vi.fn(async () => ({})),
+        };
+        const threadCh = {
+            id: 'thread1',
+            name: 'my-bead',
+            type: ChannelType.PublicThread,
+            parentId: 'forum1',
+            parent: { name: 'beads' },
+            isThread: () => true,
+            joinable: false,
+            joined: true,
+            send: vi.fn(async () => ({ edit: vi.fn(async () => { }), delete: vi.fn(async () => { }) })),
+        };
+        const channelsMap = new Map([
+            ['forum1', forumCh],
+            ['thread1', threadCh],
+        ]);
+        const guild = {
+            channels: {
+                cache: {
+                    get: (id) => channelsMap.get(id),
+                    find: (fn) => {
+                        for (const ch of channelsMap.values())
+                            if (fn(ch))
+                                return ch;
+                        return undefined;
+                    },
+                    values: () => channelsMap.values(),
+                    get size() { return channelsMap.size; },
+                },
+                create: vi.fn(async (opts) => ({ name: opts.name, id: 'new-id' })),
+            },
+        };
+        const handler = createMessageCreateHandler(baseParams(runtime, { discordActionsMessaging: true }), makeQueue());
+        const msg = makeMsg({
+            guild,
+            channel: threadCh,
+            channelId: 'thread1',
+        });
+        await handler(msg);
+        // The reply should contain the prose text.
+        const replyObj = await msg.reply.mock.results[0]?.value;
+        expect(replyObj).toBeDefined();
+        const allEditContents = replyObj.edit.mock.calls.map((c) => typeof c[0] === 'string' ? c[0] : c[0]?.content ?? '');
+        const postedContent = allEditContents[allEditContents.length - 1];
+        // Prose should be present.
+        expect(postedContent).toContain('Here is my response.');
+        // Should NOT contain a Failed: line or forum channel error text.
+        expect(postedContent).not.toContain('Failed:');
+        expect(postedContent).not.toContain('forum channel');
+        // Reply should NOT have been deleted (response was posted, not suppressed as empty).
+        expect(replyObj.delete).not.toHaveBeenCalled();
+        // Forum channel's .send() should NOT have been called.
+        expect(forumCh.send).not.toHaveBeenCalled();
+    });
+    it('does not follow up when query action fails', async () => {
+        // Guild with no channels — channelList still succeeds with empty list.
+        // Use a channelInfo with bad ID to get a failure.
+        const runtime = {
+            invoke: vi.fn(async function* () {
+                yield { type: 'text_final', text: 'Info:\n<discord-action>{"type":"channelInfo","channelId":"nonexistent"}</discord-action>' };
+            }),
+        };
+        const handler = createMessageCreateHandler(baseParams(runtime), makeQueue());
+        await handler(makeMsg());
+        // channelInfo for a non-existent channel fails -> no follow-up.
+        expect(runtime.invoke).toHaveBeenCalledTimes(1);
+    });
+    it('does not execute actions when stream is aborted without a runtime error', async () => {
+        const runtimeStarted = (() => {
+            let resolve;
+            const promise = new Promise((r) => { resolve = r; });
+            return { promise, resolve };
+        })();
+        const runtime = {
+            invoke: vi.fn(async function* (p) {
+                runtimeStarted.resolve();
+                yield {
+                    type: 'text_delta',
+                    text: 'partial output\n<discord-action>{"type":"channelCreate","name":"unsafe"}</discord-action>',
+                };
+                await new Promise((resolve) => {
+                    if (p.signal?.aborted)
+                        return resolve();
+                    p.signal?.addEventListener('abort', () => resolve(), { once: true });
+                });
+                yield { type: 'done' };
+            }),
+        };
+        const msg = makeMsg();
+        const handler = createMessageCreateHandler(baseParams(runtime), makeQueue());
+        const pending = handler(msg);
+        await runtimeStarted.promise;
+        let abortedCount = 0;
+        for (let i = 0; i < 25 && abortedCount === 0; i++) {
+            abortedCount = abortRegistry.tryAbortAll();
+            if (abortedCount === 0)
+                await Promise.resolve();
+        }
+        expect(abortedCount).toBe(1);
+        await pending;
+        expect(runtime.invoke).toHaveBeenCalledTimes(1);
+        expect(msg.guild.channels.create).not.toHaveBeenCalled();
+    });
+    it('drains all queued streaming edits before finalizing the reply', async () => {
+        vi.useFakeTimers();
+        try {
+            const unblockRuntime = (() => {
+                let resolve;
+                const promise = new Promise((r) => { resolve = r; });
+                return { promise, resolve };
+            })();
+            const unblockFirstStallEdit = (() => {
+                let resolve;
+                const promise = new Promise((r) => { resolve = r; });
+                return { promise, resolve };
+            })();
+            const runtimeStarted = (() => {
+                let resolve;
+                const promise = new Promise((r) => { resolve = r; });
+                return { promise, resolve };
+            })();
+            let stallEditCalls = 0;
+            const runtime = {
+                invoke: vi.fn(async function* () {
+                    runtimeStarted.resolve();
+                    await unblockRuntime.promise;
+                    yield { type: 'done' };
+                }),
+            };
+            const replyObj = {
+                edit: vi.fn().mockImplementation(async (payload) => {
+                    stallEditCalls++;
+                    if (stallEditCalls === 1) {
+                        await unblockFirstStallEdit.promise;
+                    }
+                }),
+                delete: vi.fn().mockResolvedValue(undefined),
+            };
+            const msg = makeMsg({ reply: vi.fn(async () => replyObj) });
+            const handler = createMessageCreateHandler(baseParams(runtime, { streamStallWarningMs: 1 }), makeQueue());
+            let settled = false;
+            const pending = handler(msg).then(() => { settled = true; });
+            await runtimeStarted.promise;
+            await vi.advanceTimersByTimeAsync(10_000);
+            expect(stallEditCalls).toBe(1);
+            unblockRuntime.resolve();
+            await Promise.resolve();
+            await Promise.resolve();
+            expect(settled).toBe(false);
+            unblockFirstStallEdit.resolve();
+            await pending;
+            expect(settled).toBe(true);
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+});
+describe('destructive action confirmation flow', () => {
+    afterEach(() => {
+        resetDestructiveConfirm();
+    });
+    it('requires !confirm token before executing destructive actions', async () => {
+        const ban = vi.fn(async () => { });
+        const guild = {
+            members: {
+                fetch: vi.fn(async () => ({ displayName: 'BadUser', ban })),
+            },
+            channels: { cache: { find: vi.fn(), values: vi.fn() } },
+        };
+        const runtime = {
+            invoke: vi.fn(async function* () {
+                yield { type: 'text_final', text: '<discord-action>{"type":"ban","userId":"42"}</discord-action>' };
+            }),
+        };
+        const handler = createMessageCreateHandler(baseParams(runtime, { discordActionsModeration: true }), makeQueue());
+        const msg1 = makeMsg({ guild, content: 'ban that user' });
+        await handler(msg1);
+        const firstReply = await msg1.reply.mock.results[0]?.value;
+        const firstContent = String(firstReply?.edit?.mock?.calls?.[firstReply.edit.mock.calls.length - 1]?.[0]?.content ?? '');
+        const token = /!confirm\s+([a-z0-9_-]{6,64})/i.exec(firstContent)?.[1];
+        expect(token).toBeTruthy();
+        expect(ban).not.toHaveBeenCalled();
+        const msg2 = makeMsg({ guild, content: `!confirm ${token}` });
+        await handler(msg2);
+        expect(runtime.invoke).toHaveBeenCalledTimes(1);
+        expect(ban).toHaveBeenCalledOnce();
+        const confirmReply = msg2.reply.mock.calls[0]?.[0]?.content ?? '';
+        expect(confirmReply).toContain('Confirmed `ban`.');
+    });
+});
+// ---------------------------------------------------------------------------
+// In-flight reply cleanup verification
+// ---------------------------------------------------------------------------
+describe('in-flight reply registry cleanup', () => {
+    afterEach(() => {
+        resetInFlight();
+        abortRegistry._resetForTest();
+    });
+    it('no leaked registry entries after normal completion', async () => {
+        const runtime = {
+            invoke: vi.fn(async function* () {
+                yield { type: 'text_final', text: 'Hello there!' };
+            }),
+        };
+        const handler = createMessageCreateHandler(baseParams(runtime), makeQueue());
+        await handler(makeMsg());
+        expect(inFlightReplyCount()).toBe(0);
+    });
+    it('no leaked registry entries after follow-up completes', async () => {
+        let callCount = 0;
+        const runtime = {
+            invoke: vi.fn(async function* () {
+                callCount++;
+                if (callCount === 1) {
+                    yield { type: 'text_final', text: 'Listing:\n<discord-action>{"type":"channelList"}</discord-action>' };
+                }
+                else {
+                    yield { type: 'text_final', text: 'Analysis complete with sufficient length to avoid suppression threshold limits.' };
+                }
+            }),
+        };
+        const handler = createMessageCreateHandler(baseParams(runtime), makeQueue());
+        await handler(makeMsg());
+        expect(runtime.invoke).toHaveBeenCalledTimes(2);
+        expect(inFlightReplyCount()).toBe(0);
+    });
+    it('no leaked registry entries after runtime error', async () => {
+        const runtime = {
+            invoke: vi.fn(async function* () {
+                yield { type: 'error', message: 'runtime crashed' };
+            }),
+        };
+        const handler = createMessageCreateHandler(baseParams(runtime), makeQueue());
+        await handler(makeMsg());
+        expect(inFlightReplyCount()).toBe(0);
+    });
+    it('requireChannelContext early return: edits reply with error, does not delete', async () => {
+        const replyObj = { edit: vi.fn(async () => { }), delete: vi.fn(async () => { }) };
+        const runtime = {
+            invoke: vi.fn(async function* () {
+                yield { type: 'text_final', text: 'should not reach' };
+            }),
+        };
+        const handler = createMessageCreateHandler(baseParams(runtime, { requireChannelContext: true }), makeQueue());
+        await handler(makeMsg({ reply: vi.fn(async () => replyObj) }));
+        // Runtime should not have been invoked (early return before invoke).
+        expect(runtime.invoke).not.toHaveBeenCalled();
+        // The reply should be edited with an error message, not deleted.
+        expect(replyObj.edit).toHaveBeenCalled();
+        expect(replyObj.delete).not.toHaveBeenCalled();
+        expect(inFlightReplyCount()).toBe(0);
+    });
+    it('context-gathering failure: edits reply with error, does not delete', async () => {
+        const replyObj = { edit: vi.fn(async () => { }), delete: vi.fn(async () => { }) };
+        const runtime = {
+            invoke: vi.fn(async function* () {
+                yield { type: 'text_final', text: 'should not reach' };
+            }),
+        };
+        // A discordChannelContext whose paContextFiles lists a non-existent required file.
+        // inlineContextFiles throws for required files that cannot be read, triggering the
+        // inner try-catch before runtime.invoke is ever called.
+        const discordChannelContext = {
+            contentDir: '/tmp',
+            indexPath: '/tmp/index.md',
+            paContextFiles: ['/nonexistent-path/required-pa-context.md'],
+            channelsDir: '/tmp/channels',
+            byChannelId: new Map(),
+            dmContextPath: '/tmp/dm.md',
+        };
+        const handler = createMessageCreateHandler(baseParams(runtime, { discordChannelContext }), makeQueue());
+        await handler(makeMsg({ reply: vi.fn(async () => replyObj) }));
+        // Runtime should not have been invoked (error occurred before invoke).
+        expect(runtime.invoke).not.toHaveBeenCalled();
+        // The reply should be edited with an error message, not deleted.
+        expect(replyObj.edit).toHaveBeenCalled();
+        expect(replyObj.delete).not.toHaveBeenCalled();
+        expect(inFlightReplyCount()).toBe(0);
+    });
+});