discoclaw 1.2.4 → 2.0.0

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

@@ -1,285 +1,47 @@
-import { describe, it, expect, vi } from 'vitest';
-import { parseVoiceCommand, handleVoiceCommand } from './voice-command.js';
-import * as voiceStatusCommand from './voice-status-command.js';
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
+import { describe, expect, it } from 'vitest';
+import { handleVoiceCommand, parseVoiceCommand } from './voice-command.js';
 function makeSnapshot(overrides = {}) {
     return {
         enabled: true,
-        sttProvider: 'deepgram',
-        ttsProvider: 'deepgram',
+        provider: 'gemini-live',
+        geminiKeySet: true,
+        model: 'gemini-2.5-pro',
         homeChannel: 'voice-home',
-        deepgramKeySet: true,
-        cartesiaKeySet: false,
         autoJoin: false,
         actionsEnabled: true,
         connections: [],
-        deepgramTtsVoice: 'aura-2-asteria-en',
         ...overrides,
     };
 }
 function makeOpts(overrides = {}) {
     return {
         voiceEnabled: true,
-        ttsProvider: 'deepgram',
+        statusSnapshot: makeSnapshot(),
         ...overrides,
     };
 }
-// ---------------------------------------------------------------------------
-// parseVoiceCommand
-// ---------------------------------------------------------------------------
 describe('parseVoiceCommand', () => {
-    // Bare command
-    it('returns status for bare !voice', () => {
+    it('supports bare, status, and help forms', () => {
         expect(parseVoiceCommand('!voice')).toEqual({ action: 'status' });
-    });
-    // status subcommand
-    it('returns status for !voice status', () => {
         expect(parseVoiceCommand('!voice status')).toEqual({ action: 'status' });
-    });
-    // set subcommand
-    it('returns set for !voice set <name>', () => {
-        expect(parseVoiceCommand('!voice set aura-2-luna-en')).toEqual({
-            action: 'set',
-            voice: 'aura-2-luna-en',
-        });
-    });
-    // help subcommand
-    it('returns help for !voice help', () => {
         expect(parseVoiceCommand('!voice help')).toEqual({ action: 'help' });
     });
-    // Case insensitivity — command and subcommand
-    it('is case-insensitive for the command token', () => {
-        expect(parseVoiceCommand('!VOICE')).toEqual({ action: 'status' });
-        expect(parseVoiceCommand('!Voice')).toEqual({ action: 'status' });
-    });
-    it('is case-insensitive for the status subcommand', () => {
-        expect(parseVoiceCommand('!VOICE STATUS')).toEqual({ action: 'status' });
-        expect(parseVoiceCommand('!Voice Status')).toEqual({ action: 'status' });
-    });
-    it('is case-insensitive for the set subcommand keyword', () => {
-        expect(parseVoiceCommand('!VOICE SET aura-2-luna-en')).toEqual({
-            action: 'set',
-            voice: 'aura-2-luna-en',
-        });
-    });
-    it('is case-insensitive for the help subcommand', () => {
-        expect(parseVoiceCommand('!VOICE HELP')).toEqual({ action: 'help' });
-    });
-    // Preserves original case for voice names
-    it('preserves original case for the voice name', () => {
-        expect(parseVoiceCommand('!voice set AURA-2-LUNA-EN')).toEqual({
-            action: 'set',
-            voice: 'AURA-2-LUNA-EN',
-        });
-        expect(parseVoiceCommand('!VOICE SET Aura-2-Asteria-EN')).toEqual({
-            action: 'set',
-            voice: 'Aura-2-Asteria-EN',
-        });
-    });
-    // Whitespace handling
-    it('trims surrounding whitespace', () => {
-        expect(parseVoiceCommand('  !voice  ')).toEqual({ action: 'status' });
-        expect(parseVoiceCommand('  !voice status  ')).toEqual({ action: 'status' });
-    });
-    it('collapses extra internal whitespace', () => {
-        expect(parseVoiceCommand('!voice  status')).toEqual({ action: 'status' });
-        expect(parseVoiceCommand('!voice   set   aura-2-luna-en')).toEqual({
-            action: 'set',
-            voice: 'aura-2-luna-en',
-        });
-    });
-    // Rejection of invalid input
-    it('returns null when !voice set has no voice name', () => {
-        expect(parseVoiceCommand('!voice set')).toBeNull();
-    });
-    it('returns null when !voice set has extra tokens', () => {
-        expect(parseVoiceCommand('!voice set aura-2-luna-en extra')).toBeNull();
-    });
-    it('returns null for !voice status with extra tokens', () => {
-        expect(parseVoiceCommand('!voice status extra')).toBeNull();
-    });
-    it('returns null for !voice help with extra tokens', () => {
-        expect(parseVoiceCommand('!voice help extra')).toBeNull();
-    });
-    it('returns null for unknown subcommands', () => {
-        expect(parseVoiceCommand('!voice bogus')).toBeNull();
-        expect(parseVoiceCommand('!voice join')).toBeNull();
-        expect(parseVoiceCommand('!voice leave')).toBeNull();
-    });
-    it('returns null for non-voice commands', () => {
-        expect(parseVoiceCommand('!health')).toBeNull();
-        expect(parseVoiceCommand('!status')).toBeNull();
-        expect(parseVoiceCommand('!models')).toBeNull();
-        expect(parseVoiceCommand('!voicex')).toBeNull();
-    });
-    it('returns null for empty input', () => {
-        expect(parseVoiceCommand('')).toBeNull();
-        expect(parseVoiceCommand('   ')).toBeNull();
-    });
-    it('handles non-string input gracefully', () => {
-        expect(parseVoiceCommand(undefined)).toBeNull();
-        expect(parseVoiceCommand(null)).toBeNull();
+    it('rejects removed set subcommand', () => {
+        expect(parseVoiceCommand('!voice set aura-2-luna-en')).toBeNull();
     });
 });
-// ---------------------------------------------------------------------------
-// handleVoiceCommand
-// ---------------------------------------------------------------------------
 describe('handleVoiceCommand', () => {
-    // Voice-disabled guard
-    describe('voice-disabled guard', () => {
-        it('returns disabled message for status when voice is off', async () => {
-            const result = await handleVoiceCommand({ action: 'status' }, makeOpts({ voiceEnabled: false }));
-            expect(result).toContain('disabled');
-            expect(result).toContain('DISCOCLAW_VOICE_ENABLED');
-        });
-        it('returns disabled message for set when voice is off', async () => {
-            const result = await handleVoiceCommand({ action: 'set', voice: 'aura-2-luna-en' }, makeOpts({ voiceEnabled: false }));
-            expect(result).toContain('disabled');
-        });
-        it('returns disabled message for help when voice is off', async () => {
-            const result = await handleVoiceCommand({ action: 'help' }, makeOpts({ voiceEnabled: false }));
-            expect(result).toContain('disabled');
-        });
-    });
-    // Status delegation
-    describe('status', () => {
-        it('delegates to renderVoiceStatusReport with the provided snapshot', async () => {
-            const snapshot = makeSnapshot();
-            const spy = vi.spyOn(voiceStatusCommand, 'renderVoiceStatusReport').mockReturnValue('```text\nstatus\n```');
-            const result = await handleVoiceCommand({ action: 'status' }, makeOpts({ statusSnapshot: snapshot }));
-            expect(spy).toHaveBeenCalledWith(snapshot, undefined);
-            expect(result).toBe('```text\nstatus\n```');
-            spy.mockRestore();
-        });
-        it('passes botDisplayName to renderVoiceStatusReport', async () => {
-            const snapshot = makeSnapshot();
-            const spy = vi.spyOn(voiceStatusCommand, 'renderVoiceStatusReport').mockReturnValue('```text\nok\n```');
-            await handleVoiceCommand({ action: 'status' }, makeOpts({ statusSnapshot: snapshot, botDisplayName: 'MyBot' }));
-            expect(spy).toHaveBeenCalledWith(snapshot, 'MyBot');
-            spy.mockRestore();
-        });
-        it('returns unavailable message when statusSnapshot is not provided', async () => {
-            const result = await handleVoiceCommand({ action: 'status' }, makeOpts({ statusSnapshot: undefined }));
-            expect(result).toContain('unavailable');
-        });
-    });
-    // Set — no active pipelines
-    describe('set — no active pipelines', () => {
-        it('updates deepgramTtsVoice in voiceConfig', async () => {
-            const voiceConfig = { deepgramTtsVoice: 'aura-2-asteria-en' };
-            await handleVoiceCommand({ action: 'set', voice: 'aura-2-luna-en' }, makeOpts({ voiceConfig, activePipelineCount: 0 }));
-            expect(voiceConfig.deepgramTtsVoice).toBe('aura-2-luna-en');
-        });
-        it('does not call restartPipelines when activePipelineCount is 0', async () => {
-            const restartPipelines = vi.fn().mockResolvedValue(undefined);
-            await handleVoiceCommand({ action: 'set', voice: 'aura-2-luna-en' }, makeOpts({ voiceConfig: {}, activePipelineCount: 0, restartPipelines }));
-            expect(restartPipelines).not.toHaveBeenCalled();
-        });
-        it('does not call restartPipelines when activePipelineCount is absent', async () => {
-            const restartPipelines = vi.fn().mockResolvedValue(undefined);
-            await handleVoiceCommand({ action: 'set', voice: 'aura-2-luna-en' }, makeOpts({ voiceConfig: {}, restartPipelines }));
-            expect(restartPipelines).not.toHaveBeenCalled();
-        });
-        it('returns "will take effect on next pipeline start" message', async () => {
-            const result = await handleVoiceCommand({ action: 'set', voice: 'aura-2-luna-en' }, makeOpts({ voiceConfig: {}, activePipelineCount: 0 }));
-            expect(result).toContain('aura-2-luna-en');
-            expect(result).toContain('next pipeline start');
-        });
-    });
-    // Set — with active pipelines
-    describe('set — with active pipelines', () => {
-        it('calls restartPipelines when there is 1 active pipeline', async () => {
-            const restartPipelines = vi.fn().mockResolvedValue(undefined);
-            const voiceConfig = { deepgramTtsVoice: 'aura-2-asteria-en' };
-            await handleVoiceCommand({ action: 'set', voice: 'aura-2-luna-en' }, makeOpts({ voiceConfig, activePipelineCount: 1, restartPipelines }));
-            expect(restartPipelines).toHaveBeenCalledOnce();
-        });
-        it('returns "1 active pipeline restarted" message for a single pipeline', async () => {
-            const restartPipelines = vi.fn().mockResolvedValue(undefined);
-            const result = await handleVoiceCommand({ action: 'set', voice: 'aura-2-luna-en' }, makeOpts({ voiceConfig: {}, activePipelineCount: 1, restartPipelines }));
-            expect(result).toContain('aura-2-luna-en');
-            expect(result).toContain('1 active pipeline');
-            expect(result).toContain('restarted');
-        });
-        it('returns "N active pipelines restarted" for multiple pipelines', async () => {
-            const restartPipelines = vi.fn().mockResolvedValue(undefined);
-            const result = await handleVoiceCommand({ action: 'set', voice: 'aura-2-luna-en' }, makeOpts({ voiceConfig: {}, activePipelineCount: 3, restartPipelines }));
-            expect(result).toContain('3 active pipelines');
-            expect(result).toContain('restarted');
-        });
-        it('still updates voiceConfig before restarting pipelines', async () => {
-            const voiceConfig = { deepgramTtsVoice: 'aura-2-asteria-en' };
-            const restartPipelines = vi.fn().mockResolvedValue(undefined);
-            await handleVoiceCommand({ action: 'set', voice: 'aura-2-luna-en' }, makeOpts({ voiceConfig, activePipelineCount: 2, restartPipelines }));
-            expect(voiceConfig.deepgramTtsVoice).toBe('aura-2-luna-en');
-        });
-    });
-    // Set — via setTtsVoice (pipeline-level)
-    describe('set — via setTtsVoice', () => {
-        it('calls setTtsVoice with the new voice name', async () => {
-            const setTtsVoice = vi.fn().mockResolvedValue(1);
-            await handleVoiceCommand({ action: 'set', voice: 'aura-2-luna-en' }, makeOpts({ setTtsVoice }));
-            expect(setTtsVoice).toHaveBeenCalledWith('aura-2-luna-en');
-        });
-        it('returns "1 active pipeline restarted" when setTtsVoice returns 1', async () => {
-            const setTtsVoice = vi.fn().mockResolvedValue(1);
-            const result = await handleVoiceCommand({ action: 'set', voice: 'aura-2-luna-en' }, makeOpts({ setTtsVoice }));
-            expect(result).toContain('aura-2-luna-en');
-            expect(result).toContain('1 active pipeline');
-            expect(result).toContain('restarted');
-        });
-        it('returns "N active pipelines restarted" when setTtsVoice returns N > 1', async () => {
-            const setTtsVoice = vi.fn().mockResolvedValue(3);
-            const result = await handleVoiceCommand({ action: 'set', voice: 'aura-2-asteria-en' }, makeOpts({ setTtsVoice }));
-            expect(result).toContain('3 active pipelines');
-            expect(result).toContain('restarted');
-        });
-        it('returns "will take effect on next pipeline start" when setTtsVoice returns 0', async () => {
-            const setTtsVoice = vi.fn().mockResolvedValue(0);
-            const result = await handleVoiceCommand({ action: 'set', voice: 'aura-2-luna-en' }, makeOpts({ setTtsVoice }));
-            expect(result).toContain('aura-2-luna-en');
-            expect(result).toContain('next pipeline start');
-        });
-        it('prefers setTtsVoice over voiceConfig + restartPipelines', async () => {
-            const setTtsVoice = vi.fn().mockResolvedValue(1);
-            const restartPipelines = vi.fn().mockResolvedValue(undefined);
-            const voiceConfig = { deepgramTtsVoice: 'aura-2-asteria-en' };
-            await handleVoiceCommand({ action: 'set', voice: 'aura-2-luna-en' }, makeOpts({ setTtsVoice, restartPipelines, voiceConfig, activePipelineCount: 1 }));
-            expect(setTtsVoice).toHaveBeenCalledOnce();
-            expect(restartPipelines).not.toHaveBeenCalled();
-        });
-    });
-    // Set — non-deepgram provider
-    describe('set — non-deepgram TTS provider', () => {
-        it('returns error message naming the current provider', async () => {
-            const result = await handleVoiceCommand({ action: 'set', voice: 'some-voice' }, makeOpts({ ttsProvider: 'cartesia' }));
-            expect(result).toContain('deepgram');
-            expect(result).toContain('cartesia');
-        });
-        it('does not modify voiceConfig when provider is not deepgram', async () => {
-            const voiceConfig = { deepgramTtsVoice: 'original' };
-            await handleVoiceCommand({ action: 'set', voice: 'new-voice' }, makeOpts({ ttsProvider: 'openai', voiceConfig }));
-            expect(voiceConfig.deepgramTtsVoice).toBe('original');
-        });
-    });
-    // Help
-    describe('help', () => {
-        it('returns help text mentioning all subcommands', async () => {
-            const result = await handleVoiceCommand({ action: 'help' }, makeOpts());
-            expect(result).toContain('!voice');
-            expect(result).toContain('status');
-            expect(result).toContain('set');
-            expect(result).toContain('help');
-        });
-        it('includes example voice names', async () => {
-            const result = await handleVoiceCommand({ action: 'help' }, makeOpts());
-            expect(result).toContain('aura-2-asteria-en');
-        });
-        it('mentions the Deepgram provider requirement', async () => {
-            const result = await handleVoiceCommand({ action: 'help' }, makeOpts());
-            expect(result).toContain('Deepgram');
-        });
+    it('returns disabled message when voice is off', async () => {
+        const result = await handleVoiceCommand({ action: 'status' }, makeOpts({ voiceEnabled: false }));
+        expect(result).toContain('Voice is disabled');
+    });
+    it('renders status when snapshot is present', async () => {
+        const result = await handleVoiceCommand({ action: 'status' }, makeOpts());
+        expect(result).toContain('Provider: gemini-live');
+    });
+    it('returns Gemini-only help text', async () => {
+        const result = await handleVoiceCommand({ action: 'help' }, makeOpts());
+        expect(result).toContain('Gemini Live only');
+        expect(result).not.toContain('!voice set');
     });
 });

package/dist/discord/voice-status-command.js

@@ -17,28 +17,9 @@ export function renderVoiceStatusReport(snapshot, botDisplayName = 'Discoclaw')
     const lines = [];
     lines.push(`${botDisplayName} Voice Status`);
     lines.push(`Voice: ${snapshot.enabled ? 'enabled' : 'disabled'}`);
-    // STT
-    if (snapshot.sttProvider === 'deepgram') {
-        const keyLabel = snapshot.deepgramKeySet ? 'key: set' : 'key: MISSING';
-        const modelLabel = snapshot.deepgramSttModel ? `, model: ${snapshot.deepgramSttModel}` : '';
-        lines.push(`STT: ${snapshot.sttProvider} (${keyLabel}${modelLabel})`);
-    }
-    else {
-        lines.push(`STT: ${snapshot.sttProvider}`);
-    }
-    // TTS
-    if (snapshot.ttsProvider === 'deepgram') {
-        const keyLabel = snapshot.deepgramKeySet ? 'key: set' : 'key: MISSING';
-        const voiceLabel = snapshot.deepgramTtsVoice ? `, voice: ${snapshot.deepgramTtsVoice}` : '';
-        lines.push(`TTS: ${snapshot.ttsProvider} (${keyLabel}${voiceLabel})`);
-    }
-    else if (snapshot.ttsProvider === 'cartesia') {
-        const keyLabel = snapshot.cartesiaKeySet ? 'key: set' : 'key: MISSING';
-        lines.push(`TTS: ${snapshot.ttsProvider} (${keyLabel})`);
-    }
-    else {
-        lines.push(`TTS: ${snapshot.ttsProvider}`);
-    }
+    const keyLabel = snapshot.geminiKeySet ? 'key: set' : 'key: MISSING';
+    const modelLabel = snapshot.model ? `, model: ${snapshot.model}` : '';
+    lines.push(`Provider: ${snapshot.provider} (${keyLabel}${modelLabel})`);
     lines.push(`Home channel: ${snapshot.homeChannel ?? '(not set)'}`);
     lines.push(`Auto-join: ${snapshot.autoJoin ? 'on' : 'off'}`);
     lines.push(`Actions: ${snapshot.actionsEnabled ? 'enabled' : 'disabled'}`);

package/dist/discord/voice-status-command.test.js

@@ -1,149 +1,41 @@
 import { describe, expect, it } from 'vitest';
-import { parseVoiceStatusCommand, renderVoiceStatusReport, } from './voice-status-command.js';
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
+import { parseVoiceStatusCommand, renderVoiceStatusReport } from './voice-status-command.js';
 function makeSnapshot(overrides = {}) {
     return {
         enabled: true,
-        sttProvider: 'deepgram',
-        ttsProvider: 'cartesia',
+        provider: 'gemini-live',
+        geminiKeySet: true,
+        model: 'gemini-2.5-pro',
         homeChannel: 'voice-home',
-        deepgramKeySet: true,
-        cartesiaKeySet: true,
         autoJoin: false,
         actionsEnabled: true,
         connections: [],
         ...overrides,
     };
 }
-// ---------------------------------------------------------------------------
-// parseVoiceStatusCommand
-// ---------------------------------------------------------------------------
 describe('parseVoiceStatusCommand', () => {
-    it('returns true for !voice status', () => {
+    it('parses !voice status case-insensitively', () => {
         expect(parseVoiceStatusCommand('!voice status')).toBe(true);
-    });
-    it('is case-insensitive', () => {
         expect(parseVoiceStatusCommand('!VOICE STATUS')).toBe(true);
-        expect(parseVoiceStatusCommand('!Voice Status')).toBe(true);
-    });
-    it('trims surrounding whitespace', () => {
-        expect(parseVoiceStatusCommand('  !voice status  ')).toBe(true);
     });
-    it('collapses extra internal whitespace', () => {
-        expect(parseVoiceStatusCommand('!voice  status')).toBe(true);
-    });
-    it('returns null for non-matching commands', () => {
+    it('rejects non-status commands', () => {
         expect(parseVoiceStatusCommand('!voice')).toBeNull();
-        expect(parseVoiceStatusCommand('!voice join')).toBeNull();
-        expect(parseVoiceStatusCommand('!status')).toBeNull();
         expect(parseVoiceStatusCommand('!health')).toBeNull();
-        expect(parseVoiceStatusCommand('')).toBeNull();
-    });
-    it('handles non-string input gracefully', () => {
-        expect(parseVoiceStatusCommand(undefined)).toBeNull();
-        expect(parseVoiceStatusCommand(null)).toBeNull();
     });
 });
-// ---------------------------------------------------------------------------
-// renderVoiceStatusReport
-// ---------------------------------------------------------------------------
 describe('renderVoiceStatusReport', () => {
-    it('renders voice enabled', () => {
-        const out = renderVoiceStatusReport(makeSnapshot({ enabled: true }));
-        expect(out).toContain('Voice: enabled');
-    });
-    it('renders voice disabled', () => {
-        const out = renderVoiceStatusReport(makeSnapshot({ enabled: false }));
-        expect(out).toContain('Voice: disabled');
-    });
-    it('renders STT deepgram with key set', () => {
-        const out = renderVoiceStatusReport(makeSnapshot({ sttProvider: 'deepgram', deepgramKeySet: true }));
-        expect(out).toContain('STT: deepgram (key: set)');
-    });
-    it('renders STT deepgram with missing key', () => {
-        const out = renderVoiceStatusReport(makeSnapshot({ sttProvider: 'deepgram', deepgramKeySet: false }));
-        expect(out).toContain('STT: deepgram (key: MISSING)');
-    });
-    it('renders STT non-deepgram provider without key info', () => {
-        const out = renderVoiceStatusReport(makeSnapshot({ sttProvider: 'openai' }));
-        expect(out).toContain('STT: openai');
-        expect(out).not.toContain('STT: openai (');
-    });
-    it('renders TTS cartesia with key set', () => {
-        const out = renderVoiceStatusReport(makeSnapshot({ ttsProvider: 'cartesia', cartesiaKeySet: true }));
-        expect(out).toContain('TTS: cartesia (key: set)');
-    });
-    it('renders TTS cartesia with missing key', () => {
-        const out = renderVoiceStatusReport(makeSnapshot({ ttsProvider: 'cartesia', cartesiaKeySet: false }));
-        expect(out).toContain('TTS: cartesia (key: MISSING)');
-    });
-    it('renders TTS deepgram with key set', () => {
-        const out = renderVoiceStatusReport(makeSnapshot({ ttsProvider: 'deepgram', deepgramKeySet: true }));
-        expect(out).toContain('TTS: deepgram (key: set)');
-    });
-    it('renders TTS deepgram with missing key', () => {
-        const out = renderVoiceStatusReport(makeSnapshot({ ttsProvider: 'deepgram', deepgramKeySet: false }));
-        expect(out).toContain('TTS: deepgram (key: MISSING)');
-    });
-    it('renders TTS non-cartesia non-deepgram provider without key info', () => {
-        const out = renderVoiceStatusReport(makeSnapshot({ ttsProvider: 'openai' }));
-        expect(out).toContain('TTS: openai');
-        expect(out).not.toContain('TTS: openai (');
-    });
-    it('renders home channel when set', () => {
-        const out = renderVoiceStatusReport(makeSnapshot({ homeChannel: 'voice-home' }));
+    it('renders Gemini Live provider details', () => {
+        const out = renderVoiceStatusReport(makeSnapshot());
+        expect(out).toContain('Provider: gemini-live (key: set, model: gemini-2.5-pro)');
         expect(out).toContain('Home channel: voice-home');
     });
-    it('renders home channel as (not set) when absent', () => {
-        const out = renderVoiceStatusReport(makeSnapshot({ homeChannel: undefined }));
-        expect(out).toContain('Home channel: (not set)');
-    });
-    it('renders auto-join on', () => {
-        const out = renderVoiceStatusReport(makeSnapshot({ autoJoin: true }));
-        expect(out).toContain('Auto-join: on');
-    });
-    it('renders auto-join off', () => {
-        const out = renderVoiceStatusReport(makeSnapshot({ autoJoin: false }));
-        expect(out).toContain('Auto-join: off');
-    });
-    it('renders actions enabled', () => {
-        const out = renderVoiceStatusReport(makeSnapshot({ actionsEnabled: true }));
-        expect(out).toContain('Actions: enabled');
-    });
-    it('renders actions disabled', () => {
-        const out = renderVoiceStatusReport(makeSnapshot({ actionsEnabled: false }));
-        expect(out).toContain('Actions: disabled');
-    });
-    it('renders Connections: none when no active connections', () => {
-        const out = renderVoiceStatusReport(makeSnapshot({ connections: [] }));
-        expect(out).toContain('Connections: none');
-    });
-    it('renders connection list with count and details', () => {
-        const snap = makeSnapshot({
-            connections: [
-                { guildId: 'g1', channelId: 'vc1', state: 'ready', selfMute: false, selfDeaf: false },
-                { guildId: 'g2', channelId: 'vc2', state: 'connecting', selfMute: true, selfDeaf: true },
-            ],
-        });
-        const out = renderVoiceStatusReport(snap);
-        expect(out).toContain('Connections (2):');
+    it('renders missing Gemini key and active connections', () => {
+        const out = renderVoiceStatusReport(makeSnapshot({
+            geminiKeySet: false,
+            connections: [{ guildId: 'g1', channelId: 'vc1', state: 'ready', selfMute: false, selfDeaf: false }],
+        }));
+        expect(out).toContain('Provider: gemini-live (key: MISSING');
+        expect(out).toContain('Connections (1):');
         expect(out).toContain('guild=g1: channel=vc1, state=ready, mute=false, deaf=false');
-        expect(out).toContain('guild=g2: channel=vc2, state=connecting, mute=true, deaf=true');
-    });
-    it('uses custom bot display name', () => {
-        const out = renderVoiceStatusReport(makeSnapshot(), 'MyBot');
-        expect(out).toContain('MyBot Voice Status');
-        expect(out).not.toContain('Discoclaw Voice Status');
-    });
-    it('defaults to Discoclaw when no name provided', () => {
-        const out = renderVoiceStatusReport(makeSnapshot());
-        expect(out).toContain('Discoclaw Voice Status');
-    });
-    it('wraps output in a fenced text code block', () => {
-        const out = renderVoiceStatusReport(makeSnapshot());
-        expect(out).toMatch(/^```text\n/);
-        expect(out).toMatch(/\n```$/);
     });
 });

package/dist/discord-followup.test.js

@@ -303,6 +303,139 @@ describe('auto-follow-up for query actions', () => {
         expect(secondPrompt).toContain('[Auto-follow-up]');
         expect(secondPrompt).toContain('Done:');
     });
+    it('microcompacts large follow-up payloads while preserving ids and failure clues', async () => {
+        let callCount = 0;
+        const runtime = {
+            invoke: vi.fn(async function* () {
+                callCount++;
+                if (callCount === 1) {
+                    yield {
+                        type: 'text_final',
+                        text: [
+                            'Review the latest results.',
+                            '<discord-action>{"type":"channelList"}</discord-action>',
+                            '<discord-action>{"type":"channelCreate","name":"ops-archive"}</discord-action>',
+                        ].join('\n'),
+                    };
+                }
+                else {
+                    yield { type: 'text_final', text: 'I preserved the key ids and the actionable failure details.' };
+                }
+            }),
+        };
+        const executeSpy = vi.spyOn(discordActions, 'executeDiscordActions').mockResolvedValue([
+            {
+                ok: true,
+                summary: [
+                    'Messages in #ops:',
+                    '[alice] alpha update (id:1001)',
+                    '[bob] beta update (id:1002)',
+                    '[carol] gamma update (id:1003)',
+                    '[dave] delta update (id:1004)',
+                    '[erin] epsilon update (id:1005)',
+                    '[frank] zeta update (id:1006)',
+                    '[grace] eta update (id:1007)',
+                    '[heidi] theta update (id:1008)',
+                    '[ivan] iota update (id:1009)',
+                ].join('\n'),
+            },
+            {
+                ok: false,
+                error: [
+                    'Forge sync failed while opening workspace state',
+                    'Workspace: /home/davidmarsh/code/discoclaw/workspace/state.json',
+                    'Last error: ENOENT: no such file or directory',
+                    'Stack: at openWorkspaceState (src/discord/actions.ts:400:12)',
+                    'Stack: at runForgeSync (src/discord/actions.ts:512:8)',
+                    'Stack: at async executeForgeAction (src/discord/actions.ts:618:3)',
+                    'Retry hint: recreate the state file, then rerun forge sync',
+                    'Node: v24.0.0',
+                    'cwd: /home/davidmarsh/code/discoclaw',
+                ].join('\n'),
+            },
+        ]);
+        try {
+            const handler = createMessageCreateHandler(baseParams(runtime), makeQueue());
+            await handler(makeMsg());
+            expect(runtime.invoke).toHaveBeenCalledTimes(2);
+            const secondPrompt = runtime.invoke.mock.calls[1][0].prompt;
+            expect(secondPrompt).toContain('[Auto-follow-up]');
+            expect(secondPrompt).toContain('Done: Messages in #ops:');
+            expect(secondPrompt).toContain('(id:1001)');
+            expect(secondPrompt).toContain('(id:1002)');
+            expect(secondPrompt).toContain('(id:1008)');
+            expect(secondPrompt).toContain('(id:1009)');
+            expect(secondPrompt).toContain('...[omitted 5 lines]');
+            expect(secondPrompt).not.toContain('(id:1005)');
+            expect(secondPrompt).toContain('Failed: Forge sync failed while opening workspace state');
+            expect(secondPrompt).toContain('Workspace: /home/davidmarsh/code/discoclaw/workspace/state.json');
+            expect(secondPrompt).toContain('Last error: ENOENT: no such file or directory');
+            expect(secondPrompt).toContain('Retry hint: recreate the state file, then rerun forge sync');
+            expect(secondPrompt).toContain('cwd: /home/davidmarsh/code/discoclaw');
+            expect(secondPrompt).not.toContain('Stack: at runForgeSync');
+        }
+        finally {
+            executeSpy.mockRestore();
+        }
+    });
+    it('keeps posted display output full while compacting the follow-up prompt', async () => {
+        let callCount = 0;
+        const runtime = {
+            invoke: vi.fn(async function* () {
+                callCount++;
+                if (callCount === 1) {
+                    yield {
+                        type: 'text_final',
+                        text: [
+                            'Here are the fetched messages.',
+                            '<discord-action>{"type":"channelList"}</discord-action>',
+                        ].join('\n'),
+                    };
+                }
+                else {
+                    yield { type: 'text_final', text: 'The compacted follow-up still had enough detail to continue.' };
+                }
+            }),
+        };
+        const executeSpy = vi.spyOn(discordActions, 'executeDiscordActions').mockResolvedValue([{
+                ok: true,
+                summary: [
+                    'Messages in #ops:',
+                    '[alice] alpha update (id:1001)',
+                    '[bob] beta update (id:1002)',
+                    '[carol] gamma update (id:1003)',
+                    '[dave] delta update (id:1004)',
+                    '[erin] epsilon update (id:1005)',
+                    '[frank] zeta update (id:1006)',
+                    '[grace] eta update (id:1007)',
+                    '[heidi] theta update (id:1008)',
+                    '[ivan] iota update (id:1009)',
+                ].join('\n'),
+            }]);
+        try {
+            const msg = makeMsg();
+            const handler = createMessageCreateHandler(baseParams(runtime), makeQueue());
+            await handler(msg);
+            expect(runtime.invoke).toHaveBeenCalledTimes(2);
+            const secondPrompt = runtime.invoke.mock.calls[1][0].prompt;
+            expect(secondPrompt).toContain('[Auto-follow-up]');
+            expect(secondPrompt).toContain('...[omitted 5 lines]');
+            expect(secondPrompt).not.toContain('(id:1005)');
+            const replyObj = await msg.reply.mock.results[0]?.value;
+            if (replyObj) {
+                const allEditContents = replyObj.edit.mock.calls.map((call) => contentFromEditArg(call[0]));
+                const postedContent = allEditContents[allEditContents.length - 1];
+                expect(postedContent).toContain('Done: Messages in #ops:');
+                expect(postedContent).toContain('(id:1001)');
+                expect(postedContent).toContain('(id:1005)');
+                expect(postedContent).toContain('(id:1009)');
+                expect(postedContent).not.toContain('...[omitted 5 lines]');
+            }
+        }
+        finally {
+            executeSpy.mockRestore();
+        }
+    });
     it('does NOT trigger follow-up for mutation-only actions', async () => {
         const runtime = {
             invoke: vi.fn(async function* () {