discoclaw 0.1.0

package/dist/discord/models-command.test.js

@@ -0,0 +1,150 @@
+import { describe, it, expect, vi } from 'vitest';
+import { parseModelsCommand, handleModelsCommand } from './models-command.js';
+import * as actionsConfig from './actions-config.js';
+// ---------------------------------------------------------------------------
+// Parser
+// ---------------------------------------------------------------------------
+describe('parseModelsCommand', () => {
+    it('parses bare !models as show', () => {
+        expect(parseModelsCommand('!models')).toEqual({ action: 'show' });
+    });
+    it('parses !models show', () => {
+        expect(parseModelsCommand('!models show')).toEqual({ action: 'show' });
+    });
+    it('parses !models help', () => {
+        expect(parseModelsCommand('!models help')).toEqual({ action: 'help' });
+    });
+    it('parses !models set with valid role and model', () => {
+        expect(parseModelsCommand('!models set chat sonnet')).toEqual({
+            action: 'set',
+            role: 'chat',
+            model: 'sonnet',
+        });
+        expect(parseModelsCommand('!models set forge-drafter opus')).toEqual({
+            action: 'set',
+            role: 'forge-drafter',
+            model: 'opus',
+        });
+    });
+    it('rejects !models set with invalid role', () => {
+        expect(parseModelsCommand('!models set bogus sonnet')).toBeNull();
+    });
+    it('rejects !models set with missing model', () => {
+        expect(parseModelsCommand('!models set chat')).toBeNull();
+    });
+    it('returns null for non-models messages', () => {
+        expect(parseModelsCommand('hello')).toBeNull();
+        expect(parseModelsCommand('!health')).toBeNull();
+        expect(parseModelsCommand('!restart')).toBeNull();
+        expect(parseModelsCommand('!modelsxyz')).toBeNull();
+    });
+    it('is case-insensitive for command and role', () => {
+        expect(parseModelsCommand('!MODELS')).toEqual({ action: 'show' });
+        expect(parseModelsCommand('!Models Show')).toEqual({ action: 'show' });
+        expect(parseModelsCommand('!MODELS SET CHAT sonnet')).toEqual({
+            action: 'set',
+            role: 'chat',
+            model: 'sonnet',
+        });
+    });
+    it('preserves original case for model token', () => {
+        expect(parseModelsCommand('!models set chat Claude-3-Opus')).toEqual({
+            action: 'set',
+            role: 'chat',
+            model: 'Claude-3-Opus',
+        });
+        expect(parseModelsCommand('!MODELS SET CHAT Sonnet')).toEqual({
+            action: 'set',
+            role: 'chat',
+            model: 'Sonnet',
+        });
+    });
+    it('handles extra whitespace', () => {
+        expect(parseModelsCommand('  !models  ')).toEqual({ action: 'show' });
+        expect(parseModelsCommand('  !models   show  ')).toEqual({ action: 'show' });
+        expect(parseModelsCommand('  !models  set  chat  sonnet  ')).toEqual({
+            action: 'set',
+            role: 'chat',
+            model: 'sonnet',
+        });
+    });
+    it('returns null for unknown subcommands', () => {
+        expect(parseModelsCommand('!models bogus')).toBeNull();
+        expect(parseModelsCommand('!models set')).toBeNull();
+        expect(parseModelsCommand('!models show now')).toBeNull();
+        expect(parseModelsCommand('!models set chat sonnet extra')).toBeNull();
+    });
+    it('parses all valid roles', () => {
+        for (const role of ['chat', 'fast', 'forge-drafter', 'forge-auditor', 'summary', 'cron', 'cron-exec']) {
+            expect(parseModelsCommand(`!models set ${role} haiku`)).toEqual({
+                action: 'set',
+                role,
+                model: 'haiku',
+            });
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// Handler
+// ---------------------------------------------------------------------------
+describe('handleModelsCommand', () => {
+    const mockConfigCtx = {
+        botParams: {
+            runtimeModel: 'sonnet',
+            summaryModel: 'haiku',
+            forgeDrafterModel: 'opus',
+            forgeAuditorModel: 'sonnet',
+        },
+        runtime: {
+            id: 'claude-code',
+            defaultModel: 'sonnet',
+        },
+    };
+    const enabled = { configCtx: mockConfigCtx, configEnabled: true };
+    it('returns startup message when configCtx is undefined but feature is enabled', () => {
+        const result = handleModelsCommand({ action: 'show' }, { configCtx: undefined, configEnabled: true });
+        expect(result).toContain('not yet available');
+        expect(result).toContain('starting up');
+    });
+    it('returns disabled message when configCtx is undefined and feature is disabled', () => {
+        const result = handleModelsCommand({ action: 'show' }, { configCtx: undefined, configEnabled: false });
+        expect(result).toContain('disabled');
+        expect(result).not.toContain('starting up');
+    });
+    it('show delegates to executeConfigAction modelShow', () => {
+        const spy = vi.spyOn(actionsConfig, 'executeConfigAction').mockReturnValue({
+            ok: true,
+            summary: '**chat**: `sonnet`\n**summary**: `haiku`',
+        });
+        const result = handleModelsCommand({ action: 'show' }, enabled);
+        expect(spy).toHaveBeenCalledWith({ type: 'modelShow' }, mockConfigCtx);
+        expect(result).toContain('sonnet');
+        spy.mockRestore();
+    });
+    it('set delegates to executeConfigAction modelSet', () => {
+        const spy = vi.spyOn(actionsConfig, 'executeConfigAction').mockReturnValue({
+            ok: true,
+            summary: 'Model updated: chat → opus',
+        });
+        const result = handleModelsCommand({ action: 'set', role: 'chat', model: 'opus' }, enabled);
+        expect(spy).toHaveBeenCalledWith({ type: 'modelSet', role: 'chat', model: 'opus' }, mockConfigCtx);
+        expect(result).toContain('Model updated');
+        spy.mockRestore();
+    });
+    it('set returns error string on failure', () => {
+        const spy = vi.spyOn(actionsConfig, 'executeConfigAction').mockReturnValue({
+            ok: false,
+            error: 'Cron subsystem not configured',
+        });
+        const result = handleModelsCommand({ action: 'set', role: 'cron', model: 'haiku' }, enabled);
+        expect(result).toContain('Error: Cron subsystem not configured');
+        spy.mockRestore();
+    });
+    it('help returns usage text with roles and examples', () => {
+        const result = handleModelsCommand({ action: 'help' }, enabled);
+        expect(result).toContain('!models commands');
+        expect(result).toContain('chat');
+        expect(result).toContain('forge-drafter');
+        expect(result).toContain('!models set chat sonnet');
+    });
+});

package/dist/discord/nickname.test.js

@@ -0,0 +1,76 @@
+import { describe, expect, it, vi } from 'vitest';
+import { setBotNickname } from '../discord.js';
+function mockGuild() {
+    const me = {
+        nickname: null,
+        user: { username: 'Discoclaw' },
+        setNickname: vi.fn().mockResolvedValue(undefined),
+    };
+    return {
+        id: 'guild-1',
+        members: {
+            me,
+            fetchMe: vi.fn().mockResolvedValue(me),
+        },
+    };
+}
+function mockLog() {
+    return { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+}
+describe('setBotNickname', () => {
+    it('sets nickname when different from current', async () => {
+        const guild = mockGuild();
+        const log = mockLog();
+        await setBotNickname(guild, 'Weston', log);
+        expect(guild.members.me.setNickname).toHaveBeenCalledWith('Weston', 'Automatic nickname from bot identity');
+        expect(log.info).toHaveBeenCalledWith(expect.objectContaining({ guildId: 'guild-1', nickname: 'Weston' }), 'discord:nickname set');
+    });
+    it('skips when nickname already matches', async () => {
+        const me = { nickname: 'Weston', user: { username: 'Discoclaw' }, setNickname: vi.fn() };
+        const guild = { id: 'guild-1', members: { me, fetchMe: vi.fn() } };
+        const log = mockLog();
+        await setBotNickname(guild, 'Weston', log);
+        expect(me.setNickname).not.toHaveBeenCalled();
+    });
+    it('skips when username matches and no nickname set', async () => {
+        const me = { nickname: null, user: { username: 'Weston' }, setNickname: vi.fn() };
+        const guild = { id: 'guild-1', members: { me, fetchMe: vi.fn() } };
+        const log = mockLog();
+        await setBotNickname(guild, 'Weston', log);
+        expect(me.setNickname).not.toHaveBeenCalled();
+    });
+    it('handles missing permissions gracefully (error code 50013)', async () => {
+        const err = Object.assign(new Error('Missing Permissions'), { code: 50013 });
+        const guild = mockGuild();
+        guild.members.me.setNickname = vi.fn().mockRejectedValue(err);
+        const log = mockLog();
+        await setBotNickname(guild, 'Weston', log);
+        expect(log.warn).toHaveBeenCalledWith(expect.objectContaining({ guildId: 'guild-1' }), 'discord:nickname Missing Permissions — cannot set nickname');
+    });
+    it('handles null guild.members.me by calling fetchMe()', async () => {
+        const me = {
+            nickname: null,
+            user: { username: 'Discoclaw' },
+            setNickname: vi.fn().mockResolvedValue(undefined),
+        };
+        const guild = {
+            id: 'guild-1',
+            members: {
+                me: null,
+                fetchMe: vi.fn().mockResolvedValue(me),
+            },
+        };
+        const log = mockLog();
+        await setBotNickname(guild, 'Weston', log);
+        expect(guild.members.fetchMe).toHaveBeenCalledOnce();
+        expect(me.setNickname).toHaveBeenCalledWith('Weston', 'Automatic nickname from bot identity');
+    });
+    it('handles other errors gracefully', async () => {
+        const err = new Error('Unknown error');
+        const guild = mockGuild();
+        guild.members.me.setNickname = vi.fn().mockRejectedValue(err);
+        const log = mockLog();
+        await setBotNickname(guild, 'Weston', log);
+        expect(log.warn).toHaveBeenCalledWith(expect.objectContaining({ err, guildId: 'guild-1' }), 'discord:nickname failed to set');
+    });
+});

package/dist/discord/onboarding-completion.js

@@ -0,0 +1,55 @@
+/**
+ * completeOnboarding — single owner of post-onboarding logic.
+ *
+ * Writes workspace files, optionally dispatches a morning check-in cron job,
+ * and sends the outcome message to the user.
+ */
+import { writeWorkspaceFiles } from '../onboarding/onboarding-writer.js';
+import { executeCronAction } from './actions-crons.js';
+import { NO_MENTIONS } from './allowed-mentions.js';
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+/**
+ * Complete the onboarding flow: write workspace files, optionally create the
+ * morning check-in cron, and send a summary message to the user.
+ *
+ * Cron dispatch failure is logged but does not fail onboarding.
+ */
+export async function completeOnboarding(values, workspaceCwd, sendTarget, cronDispatch) {
+    const writeResult = await writeWorkspaceFiles(values, workspaceCwd);
+    if (writeResult.errors.length > 0) {
+        const errorSummary = writeResult.errors.join('; ');
+        await sendTarget.send({
+            content: `Something went wrong writing your files: ${errorSummary}\n` +
+                `Type **retry** to try again, pick a number to edit a field, or \`!cancel\` to give up.`,
+            allowedMentions: NO_MENTIONS,
+        });
+        return { writeResult };
+    }
+    let cronResult;
+    if (values.morningCheckin && cronDispatch) {
+        try {
+            cronResult = await executeCronAction({
+                type: 'cronCreate',
+                name: 'Morning Check-in',
+                schedule: '0 8 * * *',
+                timezone: values.timezone,
+                channel: cronDispatch.actionCtx.channelId,
+                prompt: 'Good morning! Time for your daily check-in.',
+            }, cronDispatch.actionCtx, cronDispatch.cronCtx);
+        }
+        catch (err) {
+            cronDispatch.log?.warn({ err }, 'onboarding:cron-dispatch failed');
+            cronResult = { ok: false, error: String(err) };
+        }
+    }
+    const warnings = writeResult.warnings.length > 0
+        ? `\n\n${writeResult.warnings.join('\n')}`
+        : '';
+    await sendTarget.send({
+        content: `All set! I've written your **IDENTITY.md** and **USER.md**. I'm ready to go.${warnings}`,
+        allowedMentions: NO_MENTIONS,
+    });
+    return { writeResult, cronResult };
+}

package/dist/discord/onboarding-completion.test.js

@@ -0,0 +1,176 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { completeOnboarding } from './onboarding-completion.js';
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+vi.mock('../onboarding/onboarding-writer.js', () => ({
+    writeWorkspaceFiles: vi.fn(),
+}));
+vi.mock('./actions-crons.js', () => ({
+    executeCronAction: vi.fn(),
+}));
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const baseValues = {
+    userName: 'David',
+    timezone: 'America/New_York',
+    morningCheckin: false,
+};
+const checkinValues = {
+    ...baseValues,
+    morningCheckin: true,
+};
+function makeWriteResult(overrides) {
+    return {
+        written: ['IDENTITY.md', 'USER.md'],
+        errors: [],
+        warnings: [],
+        ...overrides,
+    };
+}
+function makeSendTarget() {
+    const send = vi.fn(async () => { });
+    return { send, asSendTarget: { send } };
+}
+function makeActionCtx() {
+    return {
+        guild: { id: 'guild-1' },
+        client: {},
+        channelId: 'ch-1',
+        messageId: 'msg-1',
+    };
+}
+function makeCronDispatch() {
+    const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    return {
+        cronCtx: {},
+        actionCtx: makeActionCtx(),
+        log,
+    };
+}
+async function getWriteWorkspaceFiles() {
+    const mod = await import('../onboarding/onboarding-writer.js');
+    return vi.mocked(mod.writeWorkspaceFiles);
+}
+async function getExecuteCronAction() {
+    const mod = await import('./actions-crons.js');
+    return vi.mocked(mod.executeCronAction);
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('completeOnboarding', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('writes workspace files', async () => {
+        const writeWorkspaceFiles = await getWriteWorkspaceFiles();
+        writeWorkspaceFiles.mockResolvedValue(makeWriteResult());
+        const { asSendTarget } = makeSendTarget();
+        await completeOnboarding(baseValues, '/workspace', asSendTarget);
+        expect(writeWorkspaceFiles).toHaveBeenCalledWith(baseValues, '/workspace');
+    });
+    it('sends success message on write success', async () => {
+        const writeWorkspaceFiles = await getWriteWorkspaceFiles();
+        writeWorkspaceFiles.mockResolvedValue(makeWriteResult());
+        const { send, asSendTarget } = makeSendTarget();
+        await completeOnboarding(baseValues, '/workspace', asSendTarget);
+        expect(send).toHaveBeenCalledOnce();
+        expect(send.mock.calls[0][0].content).toContain('All set');
+        expect(send.mock.calls[0][0].content).toContain('IDENTITY.md');
+    });
+    it('includes warnings in success message', async () => {
+        const writeWorkspaceFiles = await getWriteWorkspaceFiles();
+        writeWorkspaceFiles.mockResolvedValue(makeWriteResult({ warnings: ['USER.md has unresolved placeholders: {{name}}'] }));
+        const { send, asSendTarget } = makeSendTarget();
+        await completeOnboarding(baseValues, '/workspace', asSendTarget);
+        expect(send.mock.calls[0][0].content).toContain('unresolved placeholders');
+    });
+    it('returns writeResult in result object', async () => {
+        const writeWorkspaceFiles = await getWriteWorkspaceFiles();
+        const wr = makeWriteResult();
+        writeWorkspaceFiles.mockResolvedValue(wr);
+        const { asSendTarget } = makeSendTarget();
+        const result = await completeOnboarding(baseValues, '/workspace', asSendTarget);
+        expect(result.writeResult).toBe(wr);
+    });
+    it('sends error message and returns early on write errors', async () => {
+        const writeWorkspaceFiles = await getWriteWorkspaceFiles();
+        writeWorkspaceFiles.mockResolvedValue(makeWriteResult({ written: [], errors: ['Failed to write IDENTITY.md: EACCES'] }));
+        const executeCronAction = await getExecuteCronAction();
+        const { send, asSendTarget } = makeSendTarget();
+        const cronDispatch = makeCronDispatch();
+        const result = await completeOnboarding(checkinValues, '/workspace', asSendTarget, cronDispatch);
+        expect(send).toHaveBeenCalledOnce();
+        expect(send.mock.calls[0][0].content).toContain('went wrong');
+        expect(send.mock.calls[0][0].content).toContain('EACCES');
+        expect(result.cronResult).toBeUndefined();
+        expect(executeCronAction).not.toHaveBeenCalled();
+    });
+    it('does not dispatch cron when morningCheckin is false', async () => {
+        const writeWorkspaceFiles = await getWriteWorkspaceFiles();
+        writeWorkspaceFiles.mockResolvedValue(makeWriteResult());
+        const executeCronAction = await getExecuteCronAction();
+        const { asSendTarget } = makeSendTarget();
+        const cronDispatch = makeCronDispatch();
+        await completeOnboarding(baseValues, '/workspace', asSendTarget, cronDispatch);
+        expect(executeCronAction).not.toHaveBeenCalled();
+    });
+    it('does not dispatch cron when cronDispatch is not provided', async () => {
+        const writeWorkspaceFiles = await getWriteWorkspaceFiles();
+        writeWorkspaceFiles.mockResolvedValue(makeWriteResult());
+        const executeCronAction = await getExecuteCronAction();
+        const { asSendTarget } = makeSendTarget();
+        await completeOnboarding(checkinValues, '/workspace', asSendTarget);
+        expect(executeCronAction).not.toHaveBeenCalled();
+    });
+    it('dispatches morning cron when morningCheckin is true and cronDispatch is provided', async () => {
+        const writeWorkspaceFiles = await getWriteWorkspaceFiles();
+        writeWorkspaceFiles.mockResolvedValue(makeWriteResult());
+        const executeCronAction = await getExecuteCronAction();
+        executeCronAction.mockResolvedValue({ ok: true, summary: 'Cron created' });
+        const { asSendTarget } = makeSendTarget();
+        const cronDispatch = makeCronDispatch();
+        const result = await completeOnboarding(checkinValues, '/workspace', asSendTarget, cronDispatch);
+        expect(executeCronAction).toHaveBeenCalledOnce();
+        expect(executeCronAction).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'cronCreate',
+            name: 'Morning Check-in',
+            schedule: '0 8 * * *',
+            timezone: 'America/New_York',
+            channel: 'ch-1',
+        }), cronDispatch.actionCtx, cronDispatch.cronCtx);
+        expect(result.cronResult).toEqual({ ok: true, summary: 'Cron created' });
+    });
+    it('cron dispatch failure is logged and does not fail onboarding', async () => {
+        const writeWorkspaceFiles = await getWriteWorkspaceFiles();
+        writeWorkspaceFiles.mockResolvedValue(makeWriteResult());
+        const executeCronAction = await getExecuteCronAction();
+        executeCronAction.mockRejectedValue(new Error('Forum not found'));
+        const { send, asSendTarget } = makeSendTarget();
+        const cronDispatch = makeCronDispatch();
+        const result = await completeOnboarding(checkinValues, '/workspace', asSendTarget, cronDispatch);
+        // Onboarding still succeeds — success message sent
+        expect(send).toHaveBeenCalledOnce();
+        expect(send.mock.calls[0][0].content).toContain('All set');
+        // Error is logged
+        expect(cronDispatch.log.warn).toHaveBeenCalled();
+        // cronResult reflects the failure
+        expect(result.cronResult).toEqual(expect.objectContaining({ ok: false }));
+    });
+    it('success message suppresses all mentions', async () => {
+        const writeWorkspaceFiles = await getWriteWorkspaceFiles();
+        writeWorkspaceFiles.mockResolvedValue(makeWriteResult());
+        const { send, asSendTarget } = makeSendTarget();
+        await completeOnboarding(baseValues, '/workspace', asSendTarget);
+        expect(send.mock.calls[0][0].allowedMentions).toEqual({ parse: [] });
+    });
+    it('error message suppresses all mentions', async () => {
+        const writeWorkspaceFiles = await getWriteWorkspaceFiles();
+        writeWorkspaceFiles.mockResolvedValue(makeWriteResult({ written: [], errors: ['boom'] }));
+        const { send, asSendTarget } = makeSendTarget();
+        await completeOnboarding(baseValues, '/workspace', asSendTarget);
+        expect(send.mock.calls[0][0].allowedMentions).toEqual({ parse: [] });
+    });
+});

package/dist/discord/output-common.js

@@ -0,0 +1,178 @@
+import { AttachmentBuilder } from 'discord.js';
+import { splitDiscord, truncateCodeBlocks } from './output-utils.js';
+import { NO_MENTIONS } from './allowed-mentions.js';
+export function prepareDiscordOutput(text) {
+    const outText = truncateCodeBlocks(text);
+    return splitDiscord(outText);
+}
+export function imageMediaTypeToExtension(mediaType) {
+    switch (mediaType) {
+        case 'image/png': return 'png';
+        case 'image/jpeg': return 'jpeg';
+        case 'image/webp': return 'webp';
+        case 'image/gif': return 'gif';
+        default: return 'png';
+    }
+}
+export function buildAttachments(images) {
+    return images.map((img, i) => {
+        const ext = imageMediaTypeToExtension(img.mediaType);
+        const buf = Buffer.from(img.base64, 'base64');
+        return new AttachmentBuilder(buf, { name: `image-${i + 1}.${ext}` });
+    });
+}
+// Discord allows max 10 attachments per message.
+const MAX_ATTACHMENTS_PER_MESSAGE = 10;
+export async function editThenSendChunks(reply, channel, text, images) {
+    const attachments = images && images.length > 0 ? buildAttachments(images) : [];
+    const chunks = prepareDiscordOutput(text);
+    const hasContent = chunks.length > 0 && chunks.some((c) => c.trim().length > 0);
+    const hasImages = attachments.length > 0;
+    if (!hasContent && !hasImages) {
+        await reply.edit({ content: '(no output)', allowedMentions: NO_MENTIONS });
+        return;
+    }
+    if (!hasContent && hasImages) {
+        // Image-only: send with empty content string.
+        const firstBatch = attachments.slice(0, MAX_ATTACHMENTS_PER_MESSAGE);
+        await reply.edit({ content: '', allowedMentions: NO_MENTIONS, files: firstBatch });
+        // Overflow images in extra messages.
+        for (let i = MAX_ATTACHMENTS_PER_MESSAGE; i < attachments.length; i += MAX_ATTACHMENTS_PER_MESSAGE) {
+            await channel.send({ content: '', allowedMentions: NO_MENTIONS, files: attachments.slice(i, i + MAX_ATTACHMENTS_PER_MESSAGE) });
+        }
+        return;
+    }
+    // Text + optional images: attach images to the last chunk.
+    const lastIdx = chunks.length - 1;
+    if (lastIdx === 0 && attachments.length > 0) {
+        // Single chunk with images: one edit with files attached.
+        const firstBatch = attachments.slice(0, MAX_ATTACHMENTS_PER_MESSAGE);
+        await reply.edit({ content: chunks[0] ?? '(no output)', allowedMentions: NO_MENTIONS, files: firstBatch });
+        for (let j = MAX_ATTACHMENTS_PER_MESSAGE; j < attachments.length; j += MAX_ATTACHMENTS_PER_MESSAGE) {
+            await channel.send({ content: '', allowedMentions: NO_MENTIONS, files: attachments.slice(j, j + MAX_ATTACHMENTS_PER_MESSAGE) });
+        }
+        return;
+    }
+    // Multi-chunk: first chunk via edit, rest via send, images on last chunk.
+    await reply.edit({ content: chunks[0] ?? '(no output)', allowedMentions: NO_MENTIONS });
+    for (let i = 1; i < chunks.length; i++) {
+        if (i === lastIdx && attachments.length > 0) {
+            const firstBatch = attachments.slice(0, MAX_ATTACHMENTS_PER_MESSAGE);
+            await channel.send({ content: chunks[i], allowedMentions: NO_MENTIONS, files: firstBatch });
+            for (let j = MAX_ATTACHMENTS_PER_MESSAGE; j < attachments.length; j += MAX_ATTACHMENTS_PER_MESSAGE) {
+                await channel.send({ content: '', allowedMentions: NO_MENTIONS, files: attachments.slice(j, j + MAX_ATTACHMENTS_PER_MESSAGE) });
+            }
+        }
+        else {
+            await channel.send({ content: chunks[i], allowedMentions: NO_MENTIONS });
+        }
+    }
+}
+export async function replyThenSendChunks(message, text, images) {
+    const attachments = images && images.length > 0 ? buildAttachments(images) : [];
+    const chunks = prepareDiscordOutput(text);
+    const hasContent = chunks.length > 0 && chunks.some((c) => c.trim().length > 0);
+    const hasImages = attachments.length > 0;
+    if (!hasContent && !hasImages) {
+        await message.reply({ content: '(no output)', allowedMentions: NO_MENTIONS });
+        return;
+    }
+    if (!hasContent && hasImages) {
+        const firstBatch = attachments.slice(0, MAX_ATTACHMENTS_PER_MESSAGE);
+        await message.reply({ content: '', allowedMentions: NO_MENTIONS, files: firstBatch });
+        for (let i = MAX_ATTACHMENTS_PER_MESSAGE; i < attachments.length; i += MAX_ATTACHMENTS_PER_MESSAGE) {
+            await message.channel.send({ content: '', allowedMentions: NO_MENTIONS, files: attachments.slice(i, i + MAX_ATTACHMENTS_PER_MESSAGE) });
+        }
+        return;
+    }
+    const lastIdx = chunks.length - 1;
+    if (lastIdx === 0 && attachments.length > 0) {
+        const firstBatch = attachments.slice(0, MAX_ATTACHMENTS_PER_MESSAGE);
+        await message.reply({ content: chunks[0] ?? '(no output)', allowedMentions: NO_MENTIONS, files: firstBatch });
+        for (let j = MAX_ATTACHMENTS_PER_MESSAGE; j < attachments.length; j += MAX_ATTACHMENTS_PER_MESSAGE) {
+            await message.channel.send({ content: '', allowedMentions: NO_MENTIONS, files: attachments.slice(j, j + MAX_ATTACHMENTS_PER_MESSAGE) });
+        }
+        return;
+    }
+    await message.reply({ content: chunks[0] ?? '(no output)', allowedMentions: NO_MENTIONS });
+    for (let i = 1; i < chunks.length; i++) {
+        if (i === lastIdx && attachments.length > 0) {
+            const firstBatch = attachments.slice(0, MAX_ATTACHMENTS_PER_MESSAGE);
+            await message.channel.send({ content: chunks[i], allowedMentions: NO_MENTIONS, files: firstBatch });
+            for (let j = MAX_ATTACHMENTS_PER_MESSAGE; j < attachments.length; j += MAX_ATTACHMENTS_PER_MESSAGE) {
+                await message.channel.send({ content: '', allowedMentions: NO_MENTIONS, files: attachments.slice(j, j + MAX_ATTACHMENTS_PER_MESSAGE) });
+            }
+        }
+        else {
+            await message.channel.send({ content: chunks[i], allowedMentions: NO_MENTIONS });
+        }
+    }
+}
+/**
+ * Decides whether a follow-up placeholder message should be suppressed.
+ *
+ * Suppress when there is effectively no output: no actions, no images, no
+ * stripped-unrecognized blocks, and the cleaned text is under 50 chars.
+ *
+ * Never suppress when strippedUnrecognizedCount > 0 — the AI tried to act
+ * but the action type was unknown/disabled, so the user must see "(no output)"
+ * rather than a silent delete.
+ */
+export function shouldSuppressFollowUp(processedText, actionsCount, imagesCount, strippedUnrecognizedCount) {
+    if (strippedUnrecognizedCount > 0)
+        return false;
+    if (actionsCount > 0 || imagesCount > 0)
+        return false;
+    const chars = processedText.replace(/\s+/g, ' ').trim().length;
+    return chars < 50;
+}
+/**
+ * Build a user-facing note for action types that were stripped because they
+ * were unknown or disabled by the current action category flags.
+ */
+export function buildUnavailableActionTypesNotice(strippedTypes) {
+    const uniqueTypes = Array.from(new Set(strippedTypes.map((t) => t.trim()).filter(Boolean)));
+    if (uniqueTypes.length === 0)
+        return '';
+    const renderedTypes = uniqueTypes.map((t) => `\`${t}\``).join(', ');
+    if (uniqueTypes.length === 1) {
+        return `Ignored unavailable action type: ${renderedTypes} (unknown type or category disabled).`;
+    }
+    return `Ignored unavailable action types: ${renderedTypes} (unknown type or category disabled).`;
+}
+export function appendUnavailableActionTypesNotice(text, strippedTypes) {
+    const notice = buildUnavailableActionTypesNotice(strippedTypes);
+    if (!notice)
+        return text;
+    const base = String(text ?? '').trimEnd();
+    return base ? `${base}\n\n${notice}` : notice;
+}
+export async function sendChunks(channel, text, images) {
+    const attachments = images && images.length > 0 ? buildAttachments(images) : [];
+    const chunks = prepareDiscordOutput(text);
+    const hasContent = chunks.length > 0 && chunks.some((c) => c.trim().length > 0);
+    const hasImages = attachments.length > 0;
+    if (!hasContent && hasImages) {
+        const firstBatch = attachments.slice(0, MAX_ATTACHMENTS_PER_MESSAGE);
+        await channel.send({ content: '', allowedMentions: NO_MENTIONS, files: firstBatch });
+        for (let i = MAX_ATTACHMENTS_PER_MESSAGE; i < attachments.length; i += MAX_ATTACHMENTS_PER_MESSAGE) {
+            await channel.send({ content: '', allowedMentions: NO_MENTIONS, files: attachments.slice(i, i + MAX_ATTACHMENTS_PER_MESSAGE) });
+        }
+        return;
+    }
+    const lastIdx = chunks.length - 1;
+    for (let i = 0; i < chunks.length; i++) {
+        if (!chunks[i].trim())
+            continue;
+        if (i === lastIdx && attachments.length > 0) {
+            const firstBatch = attachments.slice(0, MAX_ATTACHMENTS_PER_MESSAGE);
+            await channel.send({ content: chunks[i], allowedMentions: NO_MENTIONS, files: firstBatch });
+            for (let j = MAX_ATTACHMENTS_PER_MESSAGE; j < attachments.length; j += MAX_ATTACHMENTS_PER_MESSAGE) {
+                await channel.send({ content: '', allowedMentions: NO_MENTIONS, files: attachments.slice(j, j + MAX_ATTACHMENTS_PER_MESSAGE) });
+            }
+        }
+        else {
+            await channel.send({ content: chunks[i], allowedMentions: NO_MENTIONS });
+        }
+    }
+}