discoclaw 1.3.0 → 2.0.0

package/dist/discord/actions.test.js

@@ -1,7 +1,7 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { ChannelType, PermissionFlagsBits } from 'discord.js';
 import { buildUnavailableActionTypesNotice } from './output-common.js';
-import { parseDiscordActions, executeDiscordActions, discordActionsPromptSection, buildTieredDiscordActionsPromptSection, buildDisplayResultLines, buildAllResultLines, withoutRequesterGatedActionFlags, } from './actions.js';
+import { parseDiscordActions, executeDiscordActions, discordActionsPromptSection, buildTieredDiscordActionsPromptSection, buildDisplayResultLines, buildAllResultLines, buildCappedResultLines, withoutRequesterGatedActionFlags, } from './actions.js';
 import { TaskStore } from '../tasks/store.js';
 import { _resetDestructiveConfirmationForTest } from './destructive-confirmation.js';
 import { shouldTriggerFollowUp } from './action-categories.js';
@@ -892,6 +892,122 @@ describe('buildAllResultLines', () => {
         ]);
     });
 });
+describe('buildCappedResultLines', () => {
+    it('microcompacts multiline readMessages-style payloads to representative id lines', () => {
+        const results = [{
+                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'),
+            }];
+        const [line] = buildCappedResultLines(results);
+        expect(line).toContain('Done: Messages in #ops:');
+        expect(line).toContain('(id:1001)');
+        expect(line).toContain('(id:1002)');
+        expect(line).toContain('(id:1008)');
+        expect(line).toContain('(id:1009)');
+        expect(line).toContain('...[omitted 5 lines]');
+        expect(line).not.toContain('(id:1005)');
+    });
+    it('keeps task thread jump URLs in multiline closeout blocks for follow-up reuse', () => {
+        const results = [{
+                ok: true,
+                summary: [
+                    'Task ws-204 closed',
+                    'Status: done',
+                    'Thread: https://discord.com/channels/111111111111111111/222222222222222222/333333333333333333',
+                    'Project: discoclaw',
+                    'Assignee: ClawBot',
+                    'Updated by: @weston',
+                    'Note: Closeout posted in the linked Discord thread.',
+                    'Artifacts: /tmp/task-closeout.md',
+                    'Next action: use taskShow ws-204 if you need the stored linkage later.',
+                    'Watcher: ops',
+                ].join('\n'),
+            }];
+        const [line] = buildCappedResultLines(results);
+        expect(line).toContain('Done: Task ws-204 closed');
+        expect(line).toContain('Status: done');
+        expect(line).toContain('Thread: https://discord.com/channels/111111111111111111/222222222222222222/333333333333333333');
+        expect(line).toContain('Artifacts: /tmp/task-closeout.md');
+        expect(line).toContain('Next action: use taskShow ws-204 if you need the stored linkage later.');
+        expect(line).toContain('...[omitted 4 lines]');
+        expect(line).not.toContain('Assignee: ClawBot');
+    });
+    it('keeps section headings and first values in memoryShow-style blocks', () => {
+        const results = [{
+                ok: true,
+                summary: [
+                    '**Durable memory:**',
+                    '- prefers black coffee',
+                    '- uses fish shell',
+                    '**By entity:**',
+                    '- [project] discoclaw migration',
+                    '**Rolling summary:**',
+                    'Working on prompt compaction.',
+                    '**Short-term memory:**',
+                    'Need task-42 and /tmp/report.md for the next reply.',
+                    'Extra noisy note A that should be dropped.',
+                    'Extra noisy note B that should be dropped.',
+                    'Extra noisy note that should be dropped.',
+                ].join('\n'),
+            }];
+        const [line] = buildCappedResultLines(results);
+        expect(line).toContain('Done: **Durable memory:**');
+        expect(line).toContain('- prefers black coffee');
+        expect(line).toContain('**By entity:**');
+        expect(line).toContain('- [project] discoclaw migration');
+        expect(line).toContain('**Rolling summary:**');
+        expect(line).toContain('Working on prompt compaction.');
+        expect(line).toContain('**Short-term memory:**');
+        expect(line).toContain('Need task-42 and /tmp/report.md for the next reply.');
+        expect(line).toContain('...[omitted ');
+        expect(line).not.toContain('Extra noisy note B that should be dropped.');
+    });
+    it('keeps failed prefixes, paths, and actionable error lines in multiline failures', () => {
+        const results = [{
+                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'),
+            }];
+        const [line] = buildCappedResultLines(results);
+        expect(line).toContain('Failed: Forge sync failed while opening workspace state');
+        expect(line).toContain('Workspace: /home/davidmarsh/code/discoclaw/workspace/state.json');
+        expect(line).toContain('Last error: ENOENT: no such file or directory');
+        expect(line).toContain('Retry hint: recreate the state file, then rerun forge sync');
+        expect(line).toContain('cwd: /home/davidmarsh/code/discoclaw');
+        expect(line).toContain('...[omitted ');
+        expect(line).not.toContain('Stack: at runForgeSync');
+    });
+    it('falls back to the final hard cap when retained text is still too long', () => {
+        const results = [{
+                ok: true,
+                summary: `Downloaded attachment to /tmp/${'x'.repeat(120)}`,
+            }];
+        const [line] = buildCappedResultLines(results, 60);
+        expect(line.length).toBeLessThanOrEqual(60);
+        expect(line).toContain('Done: Downloaded attachment');
+        expect(line.endsWith('...[truncated]')).toBe(true);
+    });
+});
 describe('discordActionsPromptSection', () => {
     it('always includes the standard guidance when actions are enabled', () => {
         const flags = {

package/dist/discord/help-command.js

@@ -23,7 +23,7 @@ export function handleHelpCommand() {
         '- `!update` — check for or apply code updates; `!update help` for details',
         '- `!restart` — restart the discoclaw service; `!restart help` for details',
         '- `!stop` — abort all active AI streams and cancel any running forge',
-        '- `!voice status` — show voice subsystem status (STT/TTS providers, connections)',
+        '- `!voice status` — show Gemini Live voice status and active connections',
         '- `!help` — this message',
     ].join('\n');
 }

package/dist/discord/message-coordinator.js

@@ -761,15 +761,12 @@ export function createMessageCreateHandler(params, queue, statusRef) {
                     const connMap = (params.voiceCtx ?? params.voiceStatusCtx)?.voiceManager.listConnections() ?? new Map();
                     const voiceSnapshot = {
                         enabled: params.voiceEnabled ?? false,
-                        sttProvider: params.voiceSttProvider ?? 'deepgram',
-                        ttsProvider: params.voiceTtsProvider ?? 'cartesia',
+                        provider: 'gemini-live',
+                        geminiKeySet: Boolean(params.geminiApiKey),
+                        model: params.voiceModelCtx?.model,
                         homeChannel: params.voiceHomeChannel,
-                        deepgramKeySet: Boolean(params.deepgramApiKey),
-                        cartesiaKeySet: Boolean(params.cartesiaApiKey),
                         autoJoin: params.voiceAutoJoin ?? false,
                         actionsEnabled: params.discordActionsVoice ?? false,
-                        deepgramSttModel: params.deepgramSttModel,
-                        deepgramTtsVoice: params.getTtsVoice?.() ?? params.deepgramTtsVoice,
                         connections: [...connMap.entries()].map(([guildId, info]) => ({
                             guildId,
                             channelId: info.channelId,
@@ -780,10 +777,8 @@ export function createMessageCreateHandler(params, queue, statusRef) {
                     };
                     const voiceReply = await handleVoiceCommand(voiceCmd, {
                         voiceEnabled: params.voiceEnabled ?? false,
-                        ttsProvider: params.voiceTtsProvider ?? 'cartesia',
                         statusSnapshot: voiceSnapshot,
                         botDisplayName: params.botDisplayName,
-                        setTtsVoice: params.setTtsVoice,
                     });
                     await msg.reply({ content: voiceReply, allowedMentions: NO_MENTIONS });
                     return;

package/dist/discord/models-command.js

@@ -127,7 +127,7 @@ export function handleModelsCommand(cmd, opts) {
             '',
             '**Note:** `!models set imagegen <model>` changes the default image generation model at runtime (persisted). Use `!models reset imagegen` to revert to the env/fallback default.',
             '',
-            '**TTS voice:** Use `!voice set <name>` to switch the Deepgram TTS voice at runtime (e.g. `!voice set aura-2-luna-en`). See `!voice help` for details.',
+            '**Voice note:** `!voice set` is gone. Gemini Live owns the output voice now; use `!voice status` for current voice runtime details.',
         ].join('\n');
     }
     if (cmd.action === 'show') {

package/dist/discord/reaction-handler.js

@@ -6,7 +6,7 @@ import { shouldCanvasPromptBeSurfaced } from '../canvas/canvas-action.js';
 import { discordSessionKey } from './session-key.js';
 import { ensureIndexedDiscordChannelContext, resolveDiscordChannelContext } from './channel-context.js';
 import { fetchMessageHistory } from './message-history.js';
-import { parseDiscordActions, executeDiscordActions, buildTieredDiscordActionsPromptSection, buildAllResultLines, appendActionResults } from './actions.js';
+import { parseDiscordActions, executeDiscordActions, buildTieredDiscordActionsPromptSection, buildCappedResultLines, appendActionResults } from './actions.js';
 import { shouldTriggerFollowUp, actionDedupeKey, isDuplicateAction, buildActionHistorySummary } from './action-categories.js';
 import { tryResolveReactionPrompt } from './reaction-prompts.js';
 import { REACTION_STOP_ABORT_CAUSE, tryAbort, isActivelyStreaming, snapshotAbort, } from './abort-registry.js';
@@ -1094,7 +1094,7 @@ function createReactionHandler(mode, params, queue, statusRef) {
                             let nextFollowUp = null;
                             if (shouldQueueFollowUp) {
                                 const token = buildFollowUpToken();
-                                const followUpLines = buildAllResultLines(actionResults);
+                                const followUpLines = buildCappedResultLines(actionResults);
                                 const failureRetryPlaceholder = buildFailureRetryPlaceholder(parsedActions, actionResults);
                                 const followUpSuffix = failureRetryPlaceholder
                                     ? `One or more actions failed. If you retry, explicitly tell the user what failed and whether the retry succeeded or failed. Do not announce success before the action confirms it.`

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

@@ -2157,6 +2157,61 @@ describe('reaction prompt interception', () => {
         expect(followUpPrompt).toContain('[Auto-follow-up]');
         expect(followUpPrompt).toContain('Failed:');
     });
+    it('microcompacts multiline action results in reaction auto-follow-up prompts', async () => {
+        const invokeCalls = [];
+        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'),
+            }]);
+        const runtime = {
+            id: 'claude_code',
+            capabilities: new Set(['streaming_text']),
+            async *invoke(p) {
+                invokeCalls.push(p);
+                if (invokeCalls.length === 1) {
+                    yield { type: 'text_final', text: '<discord-action>{"type":"channelList"}</discord-action>' };
+                }
+                else {
+                    yield { type: 'text_final', text: 'Compacted follow-up handled.' };
+                }
+                yield { type: 'done' };
+            },
+        };
+        const params = makeParams({
+            runtime,
+            discordActionsEnabled: true,
+            discordActionsChannels: true,
+            actionFollowupDepth: 1,
+        });
+        try {
+            const handler = createReactionAddHandler(params, mockQueue());
+            await handler(mockReaction(), mockUser());
+            expect(invokeCalls).toHaveLength(2);
+            const followUpPrompt = invokeCalls[1].prompt;
+            expect(followUpPrompt).toContain('[Auto-follow-up]');
+            expect(followUpPrompt).toContain('Done: Messages in #ops:');
+            expect(followUpPrompt).toContain('(id:1001)');
+            expect(followUpPrompt).toContain('(id:1002)');
+            expect(followUpPrompt).toContain('(id:1008)');
+            expect(followUpPrompt).toContain('(id:1009)');
+            expect(followUpPrompt).toContain('...[omitted 5 lines]');
+            expect(followUpPrompt).not.toContain('(id:1005)');
+        }
+        finally {
+            executeSpy.mockRestore();
+        }
+    });
     it('posts the follow-up placeholder, starts the watchdog, and carries the same lifecycle token through completion', async () => {
         const order = [];
         const invokeCalls = [];

package/dist/discord/verify-push.js

@@ -1,20 +1,35 @@
-import { execa } from 'execa';
+import { execFile } from 'node:child_process';
+import path from 'node:path';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
 // ---------------------------------------------------------------------------
 // Git helpers
 // ---------------------------------------------------------------------------
-function localGitEnv() {
+function localGitEnv(cwd) {
     const env = { ...process.env };
-    delete env.GIT_DIR;
-    delete env.GIT_WORK_TREE;
+    for (const key of Object.keys(env)) {
+        if (key.startsWith('GIT'))
+            delete env[key];
+    }
+    env.GIT_CEILING_DIRECTORIES = path.resolve(cwd);
     return env;
 }
+async function runCommand(command, args, cwd, options = {}) {
+    const result = await execFileAsync(command, args, {
+        cwd,
+        env: localGitEnv(cwd),
+        encoding: 'utf8',
+        timeout: options.timeout,
+        maxBuffer: 10 * 1024 * 1024,
+    });
+    return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+    };
+}
 async function gitIsAvailable(cwd) {
     try {
-        await execa('git', ['rev-parse', '--is-inside-work-tree'], {
-            cwd,
-            env: localGitEnv(),
-            stdio: 'pipe',
-        });
+        await runCommand('git', ['rev-parse', '--is-inside-work-tree'], cwd);
         return true;
     }
     catch {
@@ -23,11 +38,7 @@ async function gitIsAvailable(cwd) {
 }
 async function getCurrentBranch(cwd) {
     try {
-        const result = await execa('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
-            cwd,
-            env: localGitEnv(),
-            stdio: 'pipe',
-        });
+        const result = await runCommand('git', ['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
         const branch = result.stdout.trim();
         return branch && branch !== 'HEAD' ? branch : null;
     }
@@ -37,11 +48,7 @@ async function getCurrentBranch(cwd) {
 }
 async function fetchOrigin(cwd) {
     try {
-        await execa('git', ['fetch', 'origin'], {
-            cwd,
-            env: localGitEnv(),
-            stdio: 'pipe',
-        });
+        await runCommand('git', ['fetch', 'origin'], cwd);
     }
     catch {
         // Best-effort — remote may be unreachable
@@ -49,11 +56,7 @@ async function fetchOrigin(cwd) {
 }
 async function hasUpstream(cwd, branch) {
     try {
-        await execa('git', ['rev-parse', '--abbrev-ref', `${branch}@{upstream}`], {
-            cwd,
-            env: localGitEnv(),
-            stdio: 'pipe',
-        });
+        await runCommand('git', ['rev-parse', '--abbrev-ref', `${branch}@{upstream}`], cwd);
         return true;
     }
     catch {
@@ -62,7 +65,7 @@ async function hasUpstream(cwd, branch) {
 }
 async function countUnpushedCommits(cwd, branch) {
     try {
-        const result = await execa('git', ['rev-list', '--count', `${branch}@{upstream}..HEAD`], { cwd, env: localGitEnv(), stdio: 'pipe' });
+        const result = await runCommand('git', ['rev-list', '--count', `${branch}@{upstream}..HEAD`], cwd);
         return parseInt(result.stdout.trim(), 10) || 0;
     }
     catch {
@@ -76,18 +79,10 @@ async function countUnpushedCommits(cwd, branch) {
 async function isCommitOnRemote(cwd, branch, shortHash) {
     try {
         // Resolve the short hash to a full hash first
-        const result = await execa('git', ['rev-parse', shortHash], {
-            cwd,
-            env: localGitEnv(),
-            stdio: 'pipe',
-        });
+        const result = await runCommand('git', ['rev-parse', shortHash], cwd);
         const fullHash = result.stdout.trim();
         // Check if the commit is an ancestor of (reachable from) the upstream
-        await execa('git', ['merge-base', '--is-ancestor', fullHash, `${branch}@{upstream}`], {
-            cwd,
-            env: localGitEnv(),
-            stdio: 'pipe',
-        });
+        await runCommand('git', ['merge-base', '--is-ancestor', fullHash, `${branch}@{upstream}`], cwd);
         return true;
     }
     catch {
@@ -103,7 +98,7 @@ async function isCommitOnRemote(cwd, branch, shortHash) {
  */
 async function checkPRExists(branchName, cwd) {
     try {
-        const result = await execa('gh', ['pr', 'list', '--head', branchName, '--json', 'number,state,url', '--limit', '1'], { cwd, env: localGitEnv(), stdio: 'pipe', timeout: 5_000 });
+        const result = await runCommand('gh', ['pr', 'list', '--head', branchName, '--json', 'number,state,url', '--limit', '1'], cwd, { timeout: 5_000 });
         const prs = JSON.parse(result.stdout.trim() || '[]');
         if (Array.isArray(prs) && prs.length > 0) {
             return { available: true, exists: true, url: prs[0].url };

package/dist/discord/verify-push.test.js

@@ -6,12 +6,11 @@
  * Uses real git repos in temp directories to exercise the actual git
  * helper functions (no mocking of child_process).
  */
-import { describe, expect, it, beforeEach, afterEach } from 'vitest';
+import { describe, expect, it, beforeEach, afterEach, vi } from 'vitest';
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { verifyPushStatus, formatPushWarning, } from './verify-push.js';
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -29,13 +28,28 @@ function makePhase(overrides = {}) {
     };
 }
 function git(cwd, args) {
+    const env = { ...process.env };
+    for (const key of Object.keys(env)) {
+        if (key.startsWith('GIT'))
+            delete env[key];
+    }
+    env.GIT_CEILING_DIRECTORIES = cwd;
+    env.GIT_AUTHOR_NAME = 'Test';
+    env.GIT_AUTHOR_EMAIL = 'test@test';
+    env.GIT_COMMITTER_NAME = 'Test';
+    env.GIT_COMMITTER_EMAIL = 'test@test';
     return execFileSync('git', args, {
         cwd,
         encoding: 'utf-8',
         stdio: 'pipe',
-        env: { ...process.env, GIT_AUTHOR_NAME: 'Test', GIT_AUTHOR_EMAIL: 'test@test', GIT_COMMITTER_NAME: 'Test', GIT_COMMITTER_EMAIL: 'test@test' },
+        env,
     }).trim();
 }
+async function loadVerifyPushModule() {
+    vi.resetModules();
+    vi.unmock('execa');
+    return import('./verify-push.js');
+}
 /** Create a temp dir with an initialized git repo and one initial commit. */
 function initRepo(dir) {
     git(dir, ['init', '--initial-branch=main']);
@@ -79,6 +93,7 @@ afterEach(() => {
 // ---------------------------------------------------------------------------
 describe('verifyPushStatus', () => {
     it('returns git-unavailable warning for non-repo directory', async () => {
+        const { verifyPushStatus } = await loadVerifyPushModule();
         const nonRepo = path.join(tmpBase, 'not-a-repo');
         fs.mkdirSync(nonRepo);
         const result = await verifyPushStatus(nonRepo, [makePhase({ status: 'done', gitCommit: 'abc1234' })]);
@@ -88,6 +103,7 @@ describe('verifyPushStatus', () => {
         expect(result.warning).toMatch(/Git is not available/);
     });
     it('returns no warning when there are no done phases with commits', async () => {
+        const { verifyPushStatus } = await loadVerifyPushModule();
         initRepo(workDir);
         const result = await verifyPushStatus(workDir, [
             makePhase({ status: 'pending' }),
@@ -99,6 +115,7 @@ describe('verifyPushStatus', () => {
         expect(result.warning).toBeUndefined();
     });
     it('warns when branch has no remote tracking branch', async () => {
+        const { verifyPushStatus } = await loadVerifyPushModule();
         initRepo(workDir);
         const hash = makeCommit(workDir, 'file1.ts', 'phase 1 work');
         const phases = [makePhase({ status: 'done', gitCommit: hash })];
@@ -110,6 +127,7 @@ describe('verifyPushStatus', () => {
         expect(result.warning).toMatch(/1 phase commit/);
     });
     it('warns about multiple unpushed phase commits with no remote', async () => {
+        const { verifyPushStatus } = await loadVerifyPushModule();
         initRepo(workDir);
         const hash1 = makeCommit(workDir, 'a.ts', 'phase 1');
         const hash2 = makeCommit(workDir, 'b.ts', 'phase 2');
@@ -123,6 +141,7 @@ describe('verifyPushStatus', () => {
         expect(result.warning).toMatch(/2 phase commit/);
     });
     it('returns clean result when all phase commits are pushed', async () => {
+        const { verifyPushStatus } = await loadVerifyPushModule();
         initRepo(workDir);
         addBareRemote(workDir, bareDir);
         const hash = makeCommit(workDir, 'file1.ts', 'phase 1 work');
@@ -136,6 +155,7 @@ describe('verifyPushStatus', () => {
         expect(result.warning).toBeUndefined();
     });
     it('detects unpushed phase commits when remote exists but commits not pushed', async () => {
+        const { verifyPushStatus } = await loadVerifyPushModule();
         initRepo(workDir);
         addBareRemote(workDir, bareDir);
         const hash = makeCommit(workDir, 'file1.ts', 'local-only work');
@@ -148,6 +168,7 @@ describe('verifyPushStatus', () => {
         expect(result.warning).toContain(hash);
     });
     it('differentiates pushed vs unpushed commits in mixed scenario', async () => {
+        const { verifyPushStatus } = await loadVerifyPushModule();
         initRepo(workDir);
         addBareRemote(workDir, bareDir);
         // Phase 1: pushed
@@ -166,6 +187,7 @@ describe('verifyPushStatus', () => {
         expect(result.warning).toMatch(/1 unpushed phase commit/);
     });
     it('ignores non-done phases even if they have gitCommit', async () => {
+        const { verifyPushStatus } = await loadVerifyPushModule();
         initRepo(workDir);
         addBareRemote(workDir, bareDir);
         const hash = makeCommit(workDir, 'wip.ts', 'work in progress');
@@ -180,6 +202,7 @@ describe('verifyPushStatus', () => {
         expect(result.warning).toBeUndefined();
     });
     it('works on a non-main branch with tracking', async () => {
+        const { verifyPushStatus } = await loadVerifyPushModule();
         initRepo(workDir);
         addBareRemote(workDir, bareDir);
         git(workDir, ['checkout', '-b', 'feature/verify-push']);
@@ -194,6 +217,7 @@ describe('verifyPushStatus', () => {
         expect(result.warning).toMatch(/feature\/verify-push/);
     });
     it('handles detached HEAD gracefully', async () => {
+        const { verifyPushStatus } = await loadVerifyPushModule();
         initRepo(workDir);
         const headHash = git(workDir, ['rev-parse', 'HEAD']);
         git(workDir, ['checkout', headHash]);
@@ -202,6 +226,7 @@ describe('verifyPushStatus', () => {
         expect(result.warning).toMatch(/Detached HEAD/);
     });
     it('includes prCheck field in results', async () => {
+        const { verifyPushStatus } = await loadVerifyPushModule();
         initRepo(workDir);
         addBareRemote(workDir, bareDir);
         const hash = makeCommit(workDir, 'file.ts', 'phase work');
@@ -217,7 +242,8 @@ describe('verifyPushStatus', () => {
 // formatPushWarning
 // ---------------------------------------------------------------------------
 describe('formatPushWarning', () => {
-    it('returns undefined when there is no warning', () => {
+    it('returns undefined when there is no warning', async () => {
+        const { formatPushWarning } = await loadVerifyPushModule();
         const result = {
             branch: 'main',
             hasRemote: true,
@@ -227,7 +253,8 @@ describe('formatPushWarning', () => {
         };
         expect(formatPushWarning(result)).toBeUndefined();
     });
-    it('formats warning with emoji and push guidance when no PR', () => {
+    it('formats warning with emoji and push guidance when no PR', async () => {
+        const { formatPushWarning } = await loadVerifyPushModule();
         const result = {
             branch: 'main',
             hasRemote: false,
@@ -242,7 +269,8 @@ describe('formatPushWarning', () => {
         expect(formatted).toContain('remote branch');
         expect(formatted).toContain('local-only');
     });
-    it('includes PR URL when PR exists', () => {
+    it('includes PR URL when PR exists', async () => {
+        const { formatPushWarning } = await loadVerifyPushModule();
         const result = {
             branch: 'feature/test',
             hasRemote: true,

package/dist/discord/voice-command.js

@@ -15,9 +15,6 @@ export function parseVoiceCommand(content) {
         return { action: 'status' };
     if (sub === 'help' && tokens.length === 2)
         return { action: 'help' };
-    // Preserve original case for voice names (e.g. "aura-2-asteria-en").
-    if (sub === 'set' && tokens.length === 3)
-        return { action: 'set', voice: tokens[2] };
     return null;
 }
 // ---------------------------------------------------------------------------
@@ -27,14 +24,9 @@ const HELP_TEXT = [
     '**!voice commands:**',
     '- `!voice` — show voice subsystem status',
     '- `!voice status` — same as above',
-    '- `!voice set <name>` — switch the Deepgram TTS voice at runtime',
     '- `!voice help` — this message',
     '',
-    '**Examples:**',
-    '- `!voice set aura-2-asteria-en`',
-    '- `!voice set aura-2-luna-en`',
-    '',
-    '**Note:** Voice name switching requires the Deepgram TTS provider (`DISCOCLAW_TTS_PROVIDER=deepgram`).',
+    'Voice now runs on Gemini Live only. The legacy STT/TTS pipeline and runtime voice switching have been removed.',
 ].join('\n');
 export async function handleVoiceCommand(cmd, opts) {
     if (!opts.voiceEnabled) {
@@ -47,28 +39,6 @@ export async function handleVoiceCommand(cmd, opts) {
             }
             return renderVoiceStatusReport(opts.statusSnapshot, opts.botDisplayName);
         }
-        case 'set': {
-            if (opts.ttsProvider !== 'deepgram') {
-                return `Voice name switching requires \`deepgram\` TTS provider (current: \`${opts.ttsProvider}\`).`;
-            }
-            if (opts.setTtsVoice) {
-                const restarted = await opts.setTtsVoice(cmd.voice);
-                const pipelineLabel = restarted === 1 ? '1 active pipeline' : `${restarted} active pipelines`;
-                return restarted > 0
-                    ? `Voice set to \`${cmd.voice}\`. ${pipelineLabel} restarted.`
-                    : `Voice set to \`${cmd.voice}\`. Will take effect on the next pipeline start.`;
-            }
-            if (opts.voiceConfig) {
-                opts.voiceConfig.deepgramTtsVoice = cmd.voice;
-            }
-            const pipelineCount = opts.activePipelineCount ?? 0;
-            if (pipelineCount > 0 && opts.restartPipelines) {
-                await opts.restartPipelines();
-                const pipelineLabel = pipelineCount === 1 ? '1 active pipeline' : `${pipelineCount} active pipelines`;
-                return `Voice set to \`${cmd.voice}\`. ${pipelineLabel} restarted.`;
-            }
-            return `Voice set to \`${cmd.voice}\`. Will take effect on the next pipeline start.`;
-        }
         case 'help': {
             return HELP_TEXT;
         }