discoclaw 1.2.4 → 2.0.0

package/dist/discord/message-coordinator.js

@@ -63,6 +63,7 @@ import { parseUpdateCommand, handleUpdateCommand } from './update-command.js';
 import { consumeDestructiveConfirmation } from './destructive-confirmation.js';
 import { globalMetrics } from '../observability/metrics.js';
 import { globalTraceStore } from '../observability/trace-store.js';
+import { summarizeTraceValue } from '../observability/trace-utils.js';
 import { OnboardingFlow } from '../onboarding/onboarding-flow.js';
 import { completeOnboarding } from './onboarding-completion.js';
 import { isOnboardingComplete } from '../workspace-bootstrap.js';
@@ -93,34 +94,6 @@ async function waitForEditOrTimeout(editOp, timeoutMs) {
         clearTimeout(timer);
     return completed;
 }
-function summarizeTraceText(value, maxChars = 160) {
-    const normalized = value.replace(/\s+/g, ' ').trim();
-    if (!normalized) {
-        return undefined;
-    }
-    if (normalized.length <= maxChars) {
-        return normalized;
-    }
-    return `${normalized.slice(0, Math.max(1, maxChars - 1))}…`;
-}
-function summarizeTraceValue(value, maxChars = 160) {
-    if (value == null) {
-        return undefined;
-    }
-    if (typeof value === 'string') {
-        return summarizeTraceText(value, maxChars);
-    }
-    try {
-        const serialized = JSON.stringify(value);
-        if (serialized) {
-            return summarizeTraceText(serialized, maxChars);
-        }
-    }
-    catch {
-        // Fall through to String(value).
-    }
-    return summarizeTraceText(String(value), maxChars);
-}
 const RELEASE_REHEARSAL_SLUG_RE = /\brr-\d{8}-\d{6}-[a-z0-9]+\b/gi;
 const QUOTED_VALUE_PATTERN = "(?:`([^`\\n]+)`|\"([^\"\\n]+)\"|'([^'\\n]+)')";
 function extractQuotedMatch(match) {
@@ -788,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,
@@ -807,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';
@@ -21,6 +21,8 @@ import { downloadMessageImages, resolveMediaType } from './image-download.js';
 import { downloadTextAttachments, classifyAttachments, downloadDocumentAttachments } from './file-download.js';
 import { mapRuntimeErrorToUserMessage } from './user-errors.js';
 import { globalMetrics } from '../observability/metrics.js';
+import { globalTraceStore } from '../observability/trace-store.js';
+import { summarizeTraceValue } from '../observability/trace-utils.js';
 import { resolveModel } from '../runtime/model-tiers.js';
 import { resolveGroundedToolCapabilities } from '../runtime/tool-capabilities.js';
 import { adaptRuntimeEventText } from './runtime-event-text-adapter.js';
@@ -522,6 +524,9 @@ function createReactionHandler(mode, params, queue, statusRef) {
                     let currentPrompt = prompt;
                     let pendingFollowUp = null;
                     const actionHistory = [];
+                    const traceId = `reaction_${randomUUID()}`;
+                    let traceOutcome = 'success';
+                    globalTraceStore.startTrace(traceId, sessionKey, 'reaction', reaction.message.channelId);
                     try {
                         // -- auto-follow-up loop --
                         while (true) {
@@ -606,8 +611,15 @@ function createReactionHandler(mode, params, queue, statusRef) {
                             const t0 = Date.now();
                             const previewMode = params.streamPreviewMode ?? 'compact';
                             const debugStreamPreviewLines = Boolean(params.debugStreamPreviewLines);
+                            const toolStartTimesByName = new Map();
                             metrics.recordInvokeStart('reaction');
                             params.log?.info({ flow: 'reaction', sessionKey }, 'obs.invoke.start');
+                            globalTraceStore.addEvent(traceId, {
+                                type: 'invoke_start',
+                                at: t0,
+                                summary: followUpDepth === 0 ? 'initial invoke' : `follow-up ${followUpDepth}`,
+                                promptPreview: summarizeTraceValue(currentPrompt, 220),
+                            });
                             let invokeError = null;
                             let lastEditAt = 0;
                             let streamEditTimeoutStreak = 0;
@@ -819,10 +831,39 @@ function createReactionHandler(mode, params, queue, statusRef) {
                                     lastEventAt = Date.now();
                                     stallWarned = false;
                                     lastStallProgressAt = 0;
-                                    if (evt.type === 'tool_start')
+                                    if (evt.type === 'tool_start') {
                                         activeToolCount++;
-                                    else if (evt.type === 'tool_end')
+                                        const startedAt = Date.now();
+                                        const existingStarts = toolStartTimesByName.get(evt.name) ?? [];
+                                        existingStarts.push(startedAt);
+                                        toolStartTimesByName.set(evt.name, existingStarts);
+                                        globalTraceStore.addEvent(traceId, {
+                                            type: 'tool_start',
+                                            at: startedAt,
+                                            toolName: evt.name,
+                                            inputSummary: summarizeTraceValue(evt.input),
+                                        });
+                                    }
+                                    else if (evt.type === 'tool_end') {
                                         activeToolCount = Math.max(0, activeToolCount - 1);
+                                        const endedAt = Date.now();
+                                        const existingStarts = toolStartTimesByName.get(evt.name) ?? [];
+                                        const startedAt = existingStarts.shift();
+                                        if (existingStarts.length > 0) {
+                                            toolStartTimesByName.set(evt.name, existingStarts);
+                                        }
+                                        else {
+                                            toolStartTimesByName.delete(evt.name);
+                                        }
+                                        globalTraceStore.addEvent(traceId, {
+                                            type: 'tool_end',
+                                            at: endedAt,
+                                            toolName: evt.name,
+                                            ok: evt.ok,
+                                            durationMs: startedAt == null ? undefined : Math.max(0, endedAt - startedAt),
+                                            outputSummary: summarizeTraceValue(evt.output),
+                                        });
+                                    }
                                     if (evt.type === 'text_final') {
                                         hadTextFinal = true;
                                         finalText = evt.text;
@@ -845,6 +886,14 @@ function createReactionHandler(mode, params, queue, statusRef) {
                                     }
                                     else if (evt.type === 'error') {
                                         invokeError = evt.message;
+                                        traceOutcome = 'error';
+                                        globalTraceStore.addEvent(traceId, {
+                                            type: 'error',
+                                            at: Date.now(),
+                                            message: evt.message,
+                                            stage: 'runtime',
+                                            summary: followUpDepth === 0 ? 'initial invoke' : `follow-up ${followUpDepth}`,
+                                        });
                                         metrics.recordInvokeResult('reaction', Date.now() - t0, false, evt.message);
                                         params.log?.error({ sessionKey, error: evt.message }, `${logPrefix}:runtime error`);
                                         params.log?.warn({ flow: 'reaction', sessionKey, error: evt.message }, 'obs.invoke.error');
@@ -864,6 +913,15 @@ function createReactionHandler(mode, params, queue, statusRef) {
                                 streamEditQueue = Promise.resolve();
                             }
                             metrics.recordInvokeResult('reaction', Date.now() - t0, !invokeError, invokeError ?? undefined);
+                            if (invokeError) {
+                                traceOutcome = 'error';
+                            }
+                            globalTraceStore.addEvent(traceId, {
+                                type: 'invoke_end',
+                                at: Date.now(),
+                                ok: !invokeError,
+                                summary: followUpDepth === 0 ? 'initial invoke' : `follow-up ${followUpDepth}`,
+                            });
                             params.log?.info({ flow: 'reaction', sessionKey, ms: Date.now() - t0, ok: !invokeError }, 'obs.invoke.end');
                             let processedText = finalText || deltaText || (collectedImages.length > 0 ? '' : '(no output)');
                             params.log?.info({ sessionKey, sessionId, ms: Date.now() - t0, hadError: Boolean(invokeError) }, `${logPrefix}:invoke:end`);
@@ -939,8 +997,18 @@ function createReactionHandler(mode, params, queue, statusRef) {
                                         spawnCtx: params.spawnCtx,
                                     });
                                     actionResults = results;
-                                    for (const result of results) {
+                                    for (let i = 0; i < results.length; i++) {
+                                        const result = results[i];
                                         metrics.recordActionResult(result.ok);
+                                        globalTraceStore.addEvent(traceId, {
+                                            type: 'action_result',
+                                            at: Date.now(),
+                                            action: parsed.actions[i]?.type ?? 'unknown',
+                                            ok: result.ok,
+                                            detail: result.ok
+                                                ? summarizeTraceValue(result.summary, 220)
+                                                : summarizeTraceValue(result.error, 220),
+                                        });
                                         params.log?.info({ flow: 'reaction', sessionKey, ok: result.ok }, 'obs.action.result');
                                     }
                                     // Record action history for follow-up dedup.
@@ -1026,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.`
@@ -1089,6 +1157,15 @@ function createReactionHandler(mode, params, queue, statusRef) {
                         } // end while (true)
                     }
                     catch (innerErr) {
+                        traceOutcome = 'error';
+                        globalTraceStore.addEvent(traceId, {
+                            type: 'error',
+                            at: Date.now(),
+                            message: innerErr instanceof Error ? innerErr.message : String(innerErr),
+                            name: innerErr instanceof Error ? innerErr.name : undefined,
+                            stack: innerErr instanceof Error ? summarizeTraceValue(innerErr.stack, 400) : undefined,
+                            stage: 'reaction_flow',
+                        });
                         // Inner catch: attempt to show the error in the reply before the finally
                         // block runs dispose(). Setting replyFinalized = true on success prevents
                         // the finally's safety-net delete from removing the error message.
@@ -1107,6 +1184,7 @@ function createReactionHandler(mode, params, queue, statusRef) {
                         throw innerErr;
                     }
                     finally {
+                        globalTraceStore.endTrace(traceId, traceOutcome);
                         // Safety net runs before dispose() so cold-start recovery can still see
                         // the in-flight entry if the delete fails.
                         if (!replyFinalized && reply && !isShuttingDown()) {

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;
         }