discoclaw 0.1.0

package/dist/discord/reaction-prompts.js

@@ -0,0 +1,118 @@
+import { NO_MENTIONS } from './allowed-mentions.js';
+export const REACTION_PROMPT_ACTION_TYPES = new Set(['reactionPrompt']);
+/**
+ * In-memory store for pending reaction prompts.
+ * Keyed by the bot's prompt message ID so the reaction handler can look up
+ * and match the correct record.
+ */
+const pendingPrompts = new Map();
+/**
+ * Register a pending prompt in the store.
+ */
+function registerPrompt(messageId, question, choices) {
+    pendingPrompts.set(messageId, { question, choices: new Set(choices) });
+}
+/**
+ * Called by the reaction handler when a user reacts to any message.
+ * If the message ID matches a pending prompt and the emoji is a valid choice,
+ * returns the matched record data (and deletes it from the map).
+ *
+ * Returns { question, chosenEmoji } if matched, null otherwise.
+ * The reaction handler should continue into its normal AI invocation flow
+ * with a prompt that conveys the user's choice.
+ */
+export function tryResolveReactionPrompt(messageId, emoji) {
+    const pending = pendingPrompts.get(messageId);
+    if (!pending)
+        return null;
+    if (!pending.choices.has(emoji))
+        return null;
+    pendingPrompts.delete(messageId);
+    return { question: pending.question, chosenEmoji: emoji };
+}
+/**
+ * Returns the number of currently pending prompts (useful for tests).
+ */
+export function pendingPromptCount() {
+    return pendingPrompts.size;
+}
+/**
+ * Clear all pending prompts — for use in tests only.
+ */
+export function _resetForTest() {
+    pendingPrompts.clear();
+}
+// ---------------------------------------------------------------------------
+// Executor
+// ---------------------------------------------------------------------------
+const MIN_CHOICES = 2;
+const MAX_CHOICES = 9;
+export async function executeReactionPromptAction(action, ctx) {
+    // Validate question.
+    if (typeof action.question !== 'string' || !action.question.trim()) {
+        return { ok: false, error: 'reactionPrompt requires a non-empty question string' };
+    }
+    // Validate choices.
+    if (!Array.isArray(action.choices) || action.choices.length < MIN_CHOICES || action.choices.length > MAX_CHOICES) {
+        return { ok: false, error: `reactionPrompt requires ${MIN_CHOICES}–${MAX_CHOICES} choices` };
+    }
+    for (const c of action.choices) {
+        if (typeof c !== 'string' || !c.trim()) {
+            return { ok: false, error: 'reactionPrompt: each choice must be a non-empty emoji string' };
+        }
+    }
+    // Resolve the channel.
+    const { guild, channelId } = ctx;
+    const channel = guild.channels.cache.get(channelId);
+    if (!channel || !('send' in channel)) {
+        return { ok: false, error: `reactionPrompt: channel "${channelId}" not found or not a text channel` };
+    }
+    // Send the prompt message (question text only — no emoji in the body).
+    let promptMessage;
+    try {
+        promptMessage = await channel.send({
+            content: action.question,
+            allowedMentions: NO_MENTIONS,
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: `reactionPrompt: failed to send prompt message: ${msg}` };
+    }
+    // Register the prompt *before* adding reactions so the reaction handler
+    // can match it as soon as the first reaction arrives.
+    registerPrompt(promptMessage.id, action.question, action.choices);
+    // Add reactions for each choice.
+    for (const emoji of action.choices) {
+        try {
+            await promptMessage.react(emoji);
+        }
+        catch (err) {
+            // Clean up the pending record so it doesn't leak on react failure.
+            pendingPrompts.delete(promptMessage.id);
+            const msg = err instanceof Error ? err.message : String(err);
+            return { ok: false, error: `reactionPrompt: failed to add reaction "${emoji}": ${msg}` };
+        }
+    }
+    return { ok: true, summary: 'Prompt sent — awaiting user reaction' };
+}
+// ---------------------------------------------------------------------------
+// Prompt section (injected into the AI's system prompt)
+// ---------------------------------------------------------------------------
+export function reactionPromptSection() {
+    return `### Reaction Prompts
+
+**reactionPrompt** — Present a yes/no or multiple-choice question to the user via emoji reactions instead of requiring a typed reply. The bot sends a dedicated message with the question text, adds each choice as a reaction, and returns immediately. When the user reacts, their choice triggers a follow-up AI invocation automatically with a prompt that conveys the user's decision.
+
+\`\`\`
+<discord-action>{"type":"reactionPrompt","question":"Should I proceed?","choices":["✅","❌"]}</discord-action>
+\`\`\`
+
+- \`question\` (required): The question text displayed to the user.
+- \`choices\` (required): 2–9 emoji strings. Each will be added as a reaction to the prompt message.
+- \`timeoutSeconds\` (optional): Accepted for compatibility but not used — the prompt waits indefinitely and the user's reaction triggers a follow-up automatically.
+
+The action returns immediately with a confirmation that the prompt was sent. When the user reacts with a valid choice, a follow-up invocation is triggered automatically so you can act on the decision.
+
+Use this for binary confirmations (✅/❌) or short option lists — not for open-ended text input.`;
+}

package/dist/discord/reaction-prompts.test.js

@@ -0,0 +1,253 @@
+import { describe, expect, it, vi, afterEach } from 'vitest';
+import { executeReactionPromptAction, tryResolveReactionPrompt, pendingPromptCount, reactionPromptSection, _resetForTest, } from './reaction-prompts.js';
+import { QUERY_ACTION_TYPES } from './action-categories.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeCtx(overrides = {}) {
+    const reactFn = vi.fn().mockResolvedValue(undefined);
+    const sendFn = vi.fn().mockResolvedValue({ id: 'prompt-msg-1', react: reactFn });
+    return {
+        guild: {
+            channels: {
+                cache: {
+                    get: vi.fn().mockReturnValue({ send: sendFn }),
+                },
+            },
+        },
+        client: {},
+        channelId: 'ch-1',
+        messageId: 'msg-1',
+        ...overrides,
+    };
+}
+function makeAction(overrides = {}) {
+    return {
+        type: 'reactionPrompt',
+        question: 'Should I proceed?',
+        choices: ['✅', '❌'],
+        ...overrides,
+    };
+}
+afterEach(() => {
+    _resetForTest();
+});
+// ---------------------------------------------------------------------------
+// Action executor — validation
+// ---------------------------------------------------------------------------
+describe('executeReactionPromptAction — validation', () => {
+    it('rejects empty question', async () => {
+        const ctx = makeCtx();
+        const result = await executeReactionPromptAction(makeAction({ question: '' }), ctx);
+        expect(result).toEqual({ ok: false, error: 'reactionPrompt requires a non-empty question string' });
+    });
+    it('rejects whitespace-only question', async () => {
+        const ctx = makeCtx();
+        const result = await executeReactionPromptAction(makeAction({ question: '   ' }), ctx);
+        expect(result).toEqual({ ok: false, error: 'reactionPrompt requires a non-empty question string' });
+    });
+    it('rejects fewer than 2 choices', async () => {
+        const ctx = makeCtx();
+        const result = await executeReactionPromptAction(makeAction({ choices: ['✅'] }), ctx);
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('2–9 choices');
+    });
+    it('rejects more than 9 choices', async () => {
+        const ctx = makeCtx();
+        const result = await executeReactionPromptAction(makeAction({ choices: ['1️⃣', '2️⃣', '3️⃣', '4️⃣', '5️⃣', '6️⃣', '7️⃣', '8️⃣', '9️⃣', '🔟'] }), ctx);
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('2–9 choices');
+    });
+    it('rejects empty string in choices array', async () => {
+        const ctx = makeCtx();
+        const result = await executeReactionPromptAction(makeAction({ choices: ['✅', ''] }), ctx);
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('non-empty emoji string');
+    });
+    it('fails when channel not found', async () => {
+        const ctx = makeCtx();
+        ctx.guild.channels.cache.get.mockReturnValue(undefined);
+        const result = await executeReactionPromptAction(makeAction(), ctx);
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('not found or not a text channel');
+    });
+    it('fails when channel has no send method', async () => {
+        const ctx = makeCtx();
+        ctx.guild.channels.cache.get.mockReturnValue({ id: 'ch-1' }); // no send
+        const result = await executeReactionPromptAction(makeAction(), ctx);
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('not found or not a text channel');
+    });
+});
+// ---------------------------------------------------------------------------
+// Action executor — happy path
+// ---------------------------------------------------------------------------
+describe('executeReactionPromptAction — happy path', () => {
+    it('sends prompt message with question text only and adds reactions', async () => {
+        const reactFn = vi.fn().mockResolvedValue(undefined);
+        const promptMsg = { id: 'prompt-1', react: reactFn };
+        const sendFn = vi.fn().mockResolvedValue(promptMsg);
+        const ctx = makeCtx();
+        ctx.guild.channels.cache.get.mockReturnValue({ send: sendFn });
+        const result = await executeReactionPromptAction(makeAction({ choices: ['✅', '❌'] }), ctx);
+        expect(result).toEqual({ ok: true, summary: 'Prompt sent — awaiting user reaction' });
+        expect(sendFn).toHaveBeenCalledOnce();
+        const sentContent = sendFn.mock.calls[0][0].content;
+        expect(sentContent).toBe('Should I proceed?');
+        expect(reactFn).toHaveBeenCalledWith('✅');
+        expect(reactFn).toHaveBeenCalledWith('❌');
+    });
+    it('registers prompt data accessible via tryResolveReactionPrompt', async () => {
+        const reactFn = vi.fn().mockResolvedValue(undefined);
+        const promptMsg = { id: 'prompt-2', react: reactFn };
+        const sendFn = vi.fn().mockResolvedValue(promptMsg);
+        const ctx = makeCtx();
+        ctx.guild.channels.cache.get.mockReturnValue({ send: sendFn });
+        await executeReactionPromptAction(makeAction({ choices: ['🔴', '🟡', '🟢'] }), ctx);
+        const resolved = tryResolveReactionPrompt('prompt-2', '🟢');
+        expect(resolved).toEqual({ question: 'Should I proceed?', chosenEmoji: '🟢' });
+    });
+    it('accepts any valid emoji choice', async () => {
+        const reactFn = vi.fn().mockResolvedValue(undefined);
+        const promptMsg = { id: 'prompt-3', react: reactFn };
+        const sendFn = vi.fn().mockResolvedValue(promptMsg);
+        const ctx = makeCtx();
+        ctx.guild.channels.cache.get.mockReturnValue({ send: sendFn });
+        const result = await executeReactionPromptAction(makeAction({ choices: ['👍', '👎'] }), ctx);
+        expect(result).toEqual({ ok: true, summary: 'Prompt sent — awaiting user reaction' });
+        const resolved = tryResolveReactionPrompt('prompt-3', '👎');
+        expect(resolved).toEqual({ question: 'Should I proceed?', chosenEmoji: '👎' });
+    });
+    it('registry is populated before react() calls — ordering invariant', async () => {
+        let countDuringReact = -1;
+        const reactFn = vi.fn().mockImplementation(async () => {
+            // Capture pendingPromptCount at the moment react() is first called.
+            if (countDuringReact === -1) {
+                countDuringReact = pendingPromptCount();
+            }
+        });
+        const promptMsg = { id: 'prompt-order', react: reactFn };
+        const sendFn = vi.fn().mockResolvedValue(promptMsg);
+        const ctx = makeCtx();
+        ctx.guild.channels.cache.get.mockReturnValue({ send: sendFn });
+        await executeReactionPromptAction(makeAction({ choices: ['✅', '❌'] }), ctx);
+        // Registration must have occurred before the first react() call.
+        expect(countDuringReact).toBe(1);
+    });
+    it('accepts timeoutSeconds without error (field is ignored)', async () => {
+        const reactFn = vi.fn().mockResolvedValue(undefined);
+        const promptMsg = { id: 'prompt-clamp', react: reactFn };
+        const sendFn = vi.fn().mockResolvedValue(promptMsg);
+        const ctx = makeCtx();
+        ctx.guild.channels.cache.get.mockReturnValue({ send: sendFn });
+        const result = await executeReactionPromptAction(makeAction({ timeoutSeconds: 9999 }), ctx);
+        expect(result).toEqual({ ok: true, summary: 'Prompt sent — awaiting user reaction' });
+    });
+    it('removes prompt from store after resolution via tryResolveReactionPrompt', async () => {
+        const reactFn = vi.fn().mockResolvedValue(undefined);
+        const promptMsg = { id: 'prompt-cleanup', react: reactFn };
+        const sendFn = vi.fn().mockResolvedValue(promptMsg);
+        const ctx = makeCtx();
+        ctx.guild.channels.cache.get.mockReturnValue({ send: sendFn });
+        const result = await executeReactionPromptAction(makeAction(), ctx);
+        expect(result.ok).toBe(true);
+        expect(pendingPromptCount()).toBe(1);
+        tryResolveReactionPrompt('prompt-cleanup', '✅');
+        expect(pendingPromptCount()).toBe(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// Action executor — error paths
+// ---------------------------------------------------------------------------
+describe('executeReactionPromptAction — error paths', () => {
+    it('returns error when send throws', async () => {
+        const ctx = makeCtx();
+        ctx.guild.channels.cache.get.mockReturnValue({
+            send: vi.fn().mockRejectedValue(new Error('Missing Permissions')),
+        });
+        const result = await executeReactionPromptAction(makeAction(), ctx);
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('Missing Permissions');
+    });
+    it('returns error when react throws and cleans up pending prompt', async () => {
+        const reactFn = vi.fn().mockRejectedValue(new Error('Unknown Emoji'));
+        const promptMsg = { id: 'prompt-react-err', react: reactFn };
+        const sendFn = vi.fn().mockResolvedValue(promptMsg);
+        const ctx = makeCtx();
+        ctx.guild.channels.cache.get.mockReturnValue({ send: sendFn });
+        const result = await executeReactionPromptAction(makeAction(), ctx);
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('Unknown Emoji');
+        expect(pendingPromptCount()).toBe(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// tryResolveReactionPrompt
+// ---------------------------------------------------------------------------
+describe('tryResolveReactionPrompt', () => {
+    it('returns null for unknown message ID', () => {
+        expect(tryResolveReactionPrompt('nonexistent', '✅')).toBeNull();
+    });
+    it('returns null when emoji is not a valid choice', async () => {
+        const reactFn = vi.fn().mockResolvedValue(undefined);
+        const promptMsg = { id: 'prompt-invalid-emoji', react: reactFn };
+        const sendFn = vi.fn().mockResolvedValue(promptMsg);
+        const ctx = makeCtx();
+        ctx.guild.channels.cache.get.mockReturnValue({ send: sendFn });
+        await executeReactionPromptAction(makeAction({ choices: ['✅', '❌'] }), ctx);
+        expect(tryResolveReactionPrompt('prompt-invalid-emoji', '🔥')).toBeNull();
+        expect(pendingPromptCount()).toBe(1);
+        const resolved = tryResolveReactionPrompt('prompt-invalid-emoji', '✅');
+        expect(resolved).toEqual({ question: 'Should I proceed?', chosenEmoji: '✅' });
+    });
+    it('returns matched data when emoji matches', async () => {
+        const reactFn = vi.fn().mockResolvedValue(undefined);
+        const promptMsg = { id: 'prompt-match', react: reactFn };
+        const sendFn = vi.fn().mockResolvedValue(promptMsg);
+        const ctx = makeCtx();
+        ctx.guild.channels.cache.get.mockReturnValue({ send: sendFn });
+        await executeReactionPromptAction(makeAction(), ctx);
+        const result = tryResolveReactionPrompt('prompt-match', '✅');
+        expect(result).toEqual({ question: 'Should I proceed?', chosenEmoji: '✅' });
+    });
+    it('only resolves once — second call returns null', async () => {
+        const reactFn = vi.fn().mockResolvedValue(undefined);
+        const promptMsg = { id: 'prompt-once', react: reactFn };
+        const sendFn = vi.fn().mockResolvedValue(promptMsg);
+        const ctx = makeCtx();
+        ctx.guild.channels.cache.get.mockReturnValue({ send: sendFn });
+        await executeReactionPromptAction(makeAction(), ctx);
+        expect(tryResolveReactionPrompt('prompt-once', '✅')).not.toBeNull();
+        expect(tryResolveReactionPrompt('prompt-once', '✅')).toBeNull();
+    });
+});
+// ---------------------------------------------------------------------------
+// reactionPromptSection
+// ---------------------------------------------------------------------------
+describe('reactionPromptSection', () => {
+    it('contains the action type name', () => {
+        expect(reactionPromptSection()).toContain('reactionPrompt');
+    });
+    it('documents required fields', () => {
+        const section = reactionPromptSection();
+        expect(section).toContain('question');
+        expect(section).toContain('choices');
+        expect(section).toContain('timeoutSeconds');
+    });
+    it('includes a usage example', () => {
+        const section = reactionPromptSection();
+        expect(section).toContain('<discord-action>');
+        expect(section).toContain('✅');
+    });
+    it('mentions choice count limits', () => {
+        expect(reactionPromptSection()).toContain('2–9');
+    });
+});
+// ---------------------------------------------------------------------------
+// QUERY_ACTION_TYPES regression guard
+// ---------------------------------------------------------------------------
+describe('QUERY_ACTION_TYPES exclusion', () => {
+    it('reactionPrompt is not in QUERY_ACTION_TYPES (fire-and-forget, not a query)', () => {
+        expect(QUERY_ACTION_TYPES.has('reactionPrompt')).toBe(false);
+    });
+});

package/dist/discord/reply-reference.js

@@ -0,0 +1,66 @@
+import { MAX_IMAGES_PER_INVOCATION } from '../runtime/types.js';
+import { downloadMessageImages, resolveMediaType } from './image-download.js';
+/**
+ * Resolve a Discord reply reference into a prompt section and any image attachments.
+ *
+ * Returns null if the message has no reference or if the fetch fails.
+ * Images from the referenced message share the global MAX_IMAGES_PER_INVOCATION budget;
+ * pass `usedImages` to account for images already claimed.
+ */
+export async function resolveReplyReference(msg, botDisplayName, log, usedImages = 0) {
+    const refId = msg.reference?.messageId;
+    if (!refId)
+        return null;
+    try {
+        const refMsg = await msg.channel.messages.fetch(refId);
+        // Author name
+        const author = refMsg.author.bot
+            ? (botDisplayName ?? 'Discoclaw')
+            : (refMsg.author.displayName || refMsg.author.username);
+        const content = String(refMsg.content ?? '');
+        // Note non-image attachments inline
+        const attachmentNotes = [];
+        const imageAttachments = [];
+        if (refMsg.attachments) {
+            const atts = refMsg.attachments instanceof Map
+                ? [...refMsg.attachments.values()]
+                : [...refMsg.attachments.values()];
+            for (const att of atts) {
+                if (resolveMediaType(att)) {
+                    imageAttachments.push(att);
+                }
+                else {
+                    const name = att.name ?? 'unknown';
+                    attachmentNotes.push(`[attachment: ${name}]`);
+                }
+            }
+        }
+        // Download images from the referenced message (shared budget)
+        let images = [];
+        if (imageAttachments.length > 0) {
+            const remaining = Math.max(0, MAX_IMAGES_PER_INVOCATION - usedImages);
+            if (remaining > 0) {
+                try {
+                    const dlResult = await downloadMessageImages(imageAttachments, remaining);
+                    images = dlResult.images;
+                    if (dlResult.errors.length > 0) {
+                        log?.warn({ errors: dlResult.errors }, 'discord:reply-ref image download errors');
+                    }
+                }
+                catch (err) {
+                    log?.warn({ err }, 'discord:reply-ref image download failed');
+                }
+            }
+        }
+        // Build section
+        let section = `[${author}]: ${content}`;
+        if (attachmentNotes.length > 0) {
+            section += '\n' + attachmentNotes.join('\n');
+        }
+        return { section, images };
+    }
+    catch (err) {
+        log?.warn({ err, refId }, 'discord:reply-ref fetch failed');
+        return null;
+    }
+}

package/dist/discord/reply-reference.test.js

@@ -0,0 +1,125 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { resolveReplyReference } from './reply-reference.js';
+function makeMsg(opts) {
+    const refMsg = {
+        author: opts.refAuthor ?? { username: 'TestUser', displayName: 'Test User' },
+        content: opts.refContent ?? 'hello world',
+        attachments: opts.refAttachments ?? new Map(),
+    };
+    return {
+        reference: opts.refId ? { messageId: opts.refId } : null,
+        channel: {
+            messages: {
+                fetch: opts.fetchFails
+                    ? vi.fn().mockRejectedValue(new Error('Unknown Message'))
+                    : vi.fn().mockResolvedValue(refMsg),
+            },
+        },
+    };
+}
+describe('resolveReplyReference', () => {
+    const originalFetch = globalThis.fetch;
+    beforeEach(() => {
+        globalThis.fetch = vi.fn();
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    it('returns null when no reference', async () => {
+        const msg = makeMsg({});
+        expect(await resolveReplyReference(msg, 'Weston')).toBeNull();
+    });
+    it('returns section with author and content', async () => {
+        const msg = makeMsg({ refId: '999', refContent: 'check this out' });
+        const result = await resolveReplyReference(msg, 'Weston');
+        expect(result).not.toBeNull();
+        expect(result.section).toBe('[Test User]: check this out');
+        expect(result.images).toHaveLength(0);
+    });
+    it('uses botDisplayName for bot authors', async () => {
+        const msg = makeMsg({
+            refId: '999',
+            refAuthor: { bot: true, username: 'discoclaw', displayName: 'Discoclaw' },
+            refContent: 'I said something',
+        });
+        const result = await resolveReplyReference(msg, 'Weston');
+        expect(result.section).toBe('[Weston]: I said something');
+    });
+    it('falls back to Discoclaw when botDisplayName is undefined', async () => {
+        const msg = makeMsg({
+            refId: '999',
+            refAuthor: { bot: true, username: 'discoclaw' },
+            refContent: 'bot message',
+        });
+        const result = await resolveReplyReference(msg, undefined);
+        expect(result.section).toBe('[Discoclaw]: bot message');
+    });
+    it('uses username when displayName is empty', async () => {
+        const msg = makeMsg({
+            refId: '999',
+            refAuthor: { username: 'dave123', displayName: '' },
+            refContent: 'yo',
+        });
+        const result = await resolveReplyReference(msg, 'Weston');
+        expect(result.section).toBe('[dave123]: yo');
+    });
+    it('notes non-image attachments inline', async () => {
+        const atts = new Map([
+            ['1', { url: 'https://cdn.discordapp.com/a.pdf', name: 'report.pdf', contentType: 'application/pdf', size: 100 }],
+        ]);
+        const msg = makeMsg({ refId: '999', refContent: 'see attached', refAttachments: atts });
+        const result = await resolveReplyReference(msg, 'Weston');
+        expect(result.section).toContain('[attachment: report.pdf]');
+        expect(result.images).toHaveLength(0);
+    });
+    it('downloads image attachments from referenced message', async () => {
+        const imgData = (() => { const b = Buffer.alloc(45); Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]).copy(b); return b; })();
+        globalThis.fetch.mockResolvedValue({
+            ok: true,
+            arrayBuffer: () => Promise.resolve(imgData.buffer.slice(imgData.byteOffset, imgData.byteOffset + imgData.byteLength)),
+        });
+        const atts = new Map([
+            ['1', { url: 'https://cdn.discordapp.com/attachments/1/2/photo.png', name: 'photo.png', contentType: 'image/png', size: 100 }],
+        ]);
+        const msg = makeMsg({ refId: '999', refContent: 'look at this', refAttachments: atts });
+        const result = await resolveReplyReference(msg, 'Weston');
+        expect(result.images).toHaveLength(1);
+        expect(result.images[0].mediaType).toBe('image/png');
+    });
+    it('respects shared image budget', async () => {
+        const imgData = (() => { const b = Buffer.alloc(45); Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]).copy(b); return b; })();
+        globalThis.fetch.mockResolvedValue({
+            ok: true,
+            arrayBuffer: () => Promise.resolve(imgData.buffer.slice(imgData.byteOffset, imgData.byteOffset + imgData.byteLength)),
+        });
+        const atts = new Map([
+            ['1', { url: 'https://cdn.discordapp.com/attachments/1/2/a.png', name: 'a.png', contentType: 'image/png', size: 100 }],
+            ['2', { url: 'https://cdn.discordapp.com/attachments/1/2/b.png', name: 'b.png', contentType: 'image/png', size: 100 }],
+        ]);
+        const msg = makeMsg({ refId: '999', refContent: 'images', refAttachments: atts });
+        // Budget already has 9 used, only 1 remaining
+        const result = await resolveReplyReference(msg, 'Weston', undefined, 9);
+        expect(result.images).toHaveLength(1);
+    });
+    it('skips images when budget is exhausted', async () => {
+        const atts = new Map([
+            ['1', { url: 'https://cdn.discordapp.com/attachments/1/2/a.png', name: 'a.png', contentType: 'image/png', size: 100 }],
+        ]);
+        const msg = makeMsg({ refId: '999', refContent: 'no budget', refAttachments: atts });
+        const result = await resolveReplyReference(msg, 'Weston', undefined, 10);
+        expect(result.images).toHaveLength(0);
+        expect(globalThis.fetch).not.toHaveBeenCalled();
+    });
+    it('returns null on fetch failure (deleted message)', async () => {
+        const msg = makeMsg({ refId: '999', fetchFails: true });
+        const log = { warn: vi.fn(), info: vi.fn(), error: vi.fn(), debug: vi.fn() };
+        const result = await resolveReplyReference(msg, 'Weston', log);
+        expect(result).toBeNull();
+        expect(log.warn).toHaveBeenCalled();
+    });
+    it('handles empty content gracefully', async () => {
+        const msg = makeMsg({ refId: '999', refContent: '' });
+        const result = await resolveReplyReference(msg, 'Weston');
+        expect(result.section).toBe('[Test User]: ');
+    });
+});