discoclaw 0.4.0 → 0.5.0

package/.context/discord.md

@@ -86,12 +86,15 @@ Each action category has its own flag (only active when the master switch is `1`
 | `DISCOCLAW_DISCORD_ACTIONS_MEMORY` | `1` | memoryRemember, memoryForget, memoryShow |
 | `DISCOCLAW_DISCORD_ACTIONS_DEFER` | `1` | defer |
 | `DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN` | `0` | generateImage |
+| `DISCOCLAW_DISCORD_ACTIONS_VOICE` | `0` | voiceStatus, voiceJoin, voiceLeave, voiceSetVoice |
+| `DISCOCLAW_DISCORD_ACTIONS_SPAWN` | `1` | spawnAgent |
 | _(config — always on)_ | — | modelSet, modelShow |
 
 Notes:
 - `reactionPrompt` is gated by the MESSAGING flag — it is registered via `REACTION_PROMPT_ACTION_TYPES` only when `flags.messaging` is true (`src/discord/actions.ts:113`).
 - Config actions (`modelSet`, `modelShow`) have no separate env flag. They are always enabled when the master switch is on, hardcoded in `src/index.ts`.
 - `generateImage` supports two providers: **OpenAI** (models: `dall-e-3`, `gpt-image-1`) and **Gemini** (models: `imagen-4.0-generate-001`, `imagen-4.0-fast-generate-001`, `imagen-4.0-ultra-generate-001`). Provider is auto-detected from the model prefix (`dall-e-*`/`gpt-image-*` → openai, `imagen-*` → gemini) or set explicitly via the `provider` field. OpenAI provider uses `OPENAI_API_KEY` (required) and optional `OPENAI_BASE_URL`. Gemini provider uses `IMAGEGEN_GEMINI_API_KEY`. At least one key must be set when `DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN=1`. Default model is auto-detected: if only `IMAGEGEN_GEMINI_API_KEY` is set, defaults to `imagen-4.0-generate-001`; otherwise defaults to `dall-e-3`. Override with `IMAGEGEN_DEFAULT_MODEL`.
+- `spawnAgent` is enabled by default (`DISCOCLAW_DISCORD_ACTIONS_SPAWN=1`; set to 0 to disable). Spawned agents run fire-and-forget: each agent runs its prompt via the configured runtime and posts its output directly to the target channel. Multiple `spawnAgent` actions in a single response run in parallel (bounded by `DISCOCLAW_DISCORD_ACTIONS_SPAWN_MAX_CONCURRENT`, default 8). Spawn is disabled for bot-originated messages and excluded from cron flows to prevent recursive agent chains. Spawned agents run at recursion depth 1 and cannot themselves spawn further agents.
 
 Auto-follow-up: When query actions (channelList, channelInfo, threadListArchived, forumTagList, readMessages, fetchMessage, listPins, memberInfo, roleInfo, searchMessages, eventList, taskList, taskShow, cronList, cronShow, planList, planShow, memoryShow, modelShow, forgeStatus) succeed, DiscoClaw automatically re-invokes Claude with the results. This allows Claude to reason about query results without requiring the user to send a follow-up message. Controlled by `DISCOCLAW_ACTION_FOLLOWUP_DEPTH` (default `3`, `0` disables). Mutation-only responses do not trigger follow-ups. Trivially short follow-up responses (<50 chars with no actions) are suppressed.
 

package/.context/voice.md

@@ -83,5 +83,6 @@ When `voiceEnabled=true`, the post-connect block in `src/index.ts` initializes t
 | `DEEPGRAM_API_KEY` | — | Required for deepgram STT and TTS |
 | `DEEPGRAM_STT_MODEL` | `nova-3-conversationalai` | Deepgram STT model name |
 | `DEEPGRAM_TTS_VOICE` | `aura-2-asteria-en` | Deepgram TTS voice name |
+| `DEEPGRAM_TTS_SPEED` | `1.0` | Deepgram TTS playback speed (range 0.5–1.5) |
 | `CARTESIA_API_KEY` | — | Required for cartesia TTS |
 | *(built-in)* | — | Telegraphic style instruction hardcoded into every voice AI invocation — front-loads the answer, strips preambles/markdown/filler, keeps responses short for TTS latency. Not an env var; not overridable by `DISCOCLAW_VOICE_SYSTEM_PROMPT`. |

package/.env.example.full

@@ -197,6 +197,14 @@ DISCOCLAW_DISCORD_ACTIONS_DEFER=1
 # Maximum number of pending deferred invocations allowed at once (default: 5).
 #DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_CONCURRENT=5
 
+# Allow the AI to spawn parallel sub-agents in target channels.
+# Each spawned agent is a fire-and-forget invocation that posts output to the specified channel.
+# Spawned agents run at recursion depth 1 and cannot themselves spawn further agents.
+# Default: on. Set to 0 to disable.
+#DISCOCLAW_DISCORD_ACTIONS_SPAWN=1
+# Maximum number of spawn actions that may run concurrently (default: 8).
+#DISCOCLAW_DISCORD_ACTIONS_SPAWN_MAX_CONCURRENT=8
+
 # ============================================================
 # OPTIONAL — uncomment sections you need
 # ============================================================
@@ -537,5 +545,8 @@ DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN=0
 # Deepgram TTS voice for speech synthesis (default: aura-2-asteria-en).
 # See https://developers.deepgram.com/docs/tts-models for available voices.
 #DEEPGRAM_TTS_VOICE=aura-2-asteria-en
+# Deepgram TTS playback speed (range: 0.5–1.5, default: 1.0).
+# Values below 1.0 slow down speech; values above 1.0 speed it up.
+#DEEPGRAM_TTS_SPEED=1.0
 # API key for Cartesia Sonic-3 TTS. Required when DISCOCLAW_TTS_PROVIDER=cartesia.
 #CARTESIA_API_KEY=

package/README.md

@@ -221,6 +221,18 @@ Full step-by-step guide: [docs/discord-bot-setup.md](docs/discord-bot-setup.md)
    npm install -g discoclaw
    ```
 
+   > **Fedora 43+ / GCC 14+ — `@discordjs/opus` build failure**
+   >
+   > GCC 14 promotes `-Wincompatible-pointer-types` to a hard error by default. The upstream opus C source triggers this, causing `npm install` to fail with an error like:
+   > ```
+   > error: incompatible pointer types passing ...
+   > ```
+   > **Workaround** — set the flag before installing:
+   > ```bash
+   > CFLAGS="-Wno-error=incompatible-pointer-types" npm install -g discoclaw
+   > ```
+   > This is a known upstream issue in the `@discordjs/opus` native addon. It only requires the flag override at install time; runtime behavior is unaffected.
+
 2. **Run the interactive setup wizard** (creates `.env` and scaffolds your workspace):
    ```bash
    discoclaw init

package/dist/config.js

@@ -158,6 +158,8 @@ export function parseConfig(env) {
     const discordActionsDefer = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_DEFER', true);
     const discordActionsImagegen = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN', false);
     const discordActionsVoice = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_VOICE', false);
+    const discordActionsSpawn = parseBoolean(env, 'DISCOCLAW_DISCORD_ACTIONS_SPAWN', true);
+    const spawnMaxConcurrent = parsePositiveInt(env, 'DISCOCLAW_DISCORD_ACTIONS_SPAWN_MAX_CONCURRENT', 4);
     const deferMaxDelaySeconds = parsePositiveNumber(env, 'DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_DELAY_SECONDS', DEFAULT_DISCORD_ACTIONS_DEFER_MAX_DELAY_SECONDS);
     const deferMaxConcurrent = parsePositiveInt(env, 'DISCOCLAW_DISCORD_ACTIONS_DEFER_MAX_CONCURRENT', DEFAULT_DISCORD_ACTIONS_DEFER_MAX_CONCURRENT);
     if (!discordActionsEnabled) {
@@ -176,6 +178,7 @@ export function parseConfig(env) {
             { name: 'DISCOCLAW_DISCORD_ACTIONS_DEFER', enabled: discordActionsDefer },
             { name: 'DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN', enabled: discordActionsImagegen },
             { name: 'DISCOCLAW_DISCORD_ACTIONS_VOICE', enabled: discordActionsVoice },
+            { name: 'DISCOCLAW_DISCORD_ACTIONS_SPAWN', enabled: discordActionsSpawn },
         ]
             .filter((entry) => (env[entry.name] ?? '').trim().length > 0 && entry.enabled)
             .map((entry) => entry.name);
@@ -243,6 +246,16 @@ export function parseConfig(env) {
     const deepgramApiKey = parseTrimmedString(env, 'DEEPGRAM_API_KEY');
     const deepgramSttModel = parseTrimmedString(env, 'DEEPGRAM_STT_MODEL') ?? 'nova-3-general';
     const deepgramTtsVoice = parseTrimmedString(env, 'DEEPGRAM_TTS_VOICE') ?? 'aura-2-asteria-en';
+    const deepgramTtsSpeed = (() => {
+        const raw = parseTrimmedString(env, 'DEEPGRAM_TTS_SPEED');
+        if (raw == null)
+            return undefined;
+        const n = parseFloat(raw);
+        if (!Number.isFinite(n) || n < 0.5 || n > 1.5) {
+            throw new Error(`DEEPGRAM_TTS_SPEED must be a number between 0.5 and 1.5, got "${raw}"`);
+        }
+        return n;
+    })();
     const cartesiaApiKey = parseTrimmedString(env, 'CARTESIA_API_KEY');
     const voiceModelRaw = parseTrimmedString(env, 'DISCOCLAW_VOICE_MODEL');
     const voiceSystemPrompt = (() => {
@@ -351,8 +364,10 @@ export function parseConfig(env) {
             discordActionsDefer,
             discordActionsImagegen,
             discordActionsVoice,
+            discordActionsSpawn,
             deferMaxDelaySeconds,
             deferMaxConcurrent,
+            spawnMaxConcurrent,
             messageHistoryBudget: parseNonNegativeInt(env, 'DISCOCLAW_MESSAGE_HISTORY_BUDGET', 3000),
             summaryEnabled: parseBoolean(env, 'DISCOCLAW_SUMMARY_ENABLED', true),
             summaryModel: parseTrimmedString(env, 'DISCOCLAW_SUMMARY_MODEL') ?? fastModel,
@@ -398,6 +413,7 @@ export function parseConfig(env) {
             deepgramApiKey,
             deepgramSttModel,
             deepgramTtsVoice,
+            deepgramTtsSpeed,
             cartesiaApiKey,
             forgeDrafterRuntime,
             forgeAuditorRuntime,

package/dist/discord/action-categories.js

@@ -32,6 +32,8 @@ export const QUERY_ACTION_TYPES = new Set([
     'forgeStatus',
     // Voice
     'voiceStatus',
+    // Spawn
+    'spawnAgent',
 ]);
 export function hasQueryAction(actionTypes) {
     return actionTypes.some((t) => QUERY_ACTION_TYPES.has(t));

package/dist/discord/actions-spawn.js

@@ -0,0 +1,118 @@
+import { resolveChannel, findChannelRaw, describeChannelType } from './action-utils.js';
+import { NO_MENTIONS } from './allowed-mentions.js';
+import { splitDiscord } from './output-utils.js';
+const SPAWN_TYPE_MAP = {
+    spawnAgent: true,
+};
+export const SPAWN_ACTION_TYPES = new Set(Object.keys(SPAWN_TYPE_MAP));
+// ---------------------------------------------------------------------------
+// Single executor
+// ---------------------------------------------------------------------------
+export async function executeSpawnAction(action, ctx, spawnCtx) {
+    if ((spawnCtx.depth ?? 0) >= 1) {
+        return { ok: false, error: 'spawnAgent blocked: recursion depth >= 1 (spawned agents cannot spawn further agents)' };
+    }
+    switch (action.type) {
+        case 'spawnAgent': {
+            if (!action.channel?.trim()) {
+                return { ok: false, error: 'spawnAgent requires a non-empty channel' };
+            }
+            if (!action.prompt?.trim()) {
+                return { ok: false, error: 'spawnAgent requires a non-empty prompt' };
+            }
+            // Resolve the target channel before the expensive runtime call.
+            const targetChannel = resolveChannel(ctx.guild, action.channel);
+            if (!targetChannel) {
+                const raw = findChannelRaw(ctx.guild, action.channel);
+                if (raw) {
+                    const kind = describeChannelType(raw);
+                    return { ok: false, error: `spawnAgent: "${action.channel}" is a ${kind} channel (use a text channel)` };
+                }
+                return { ok: false, error: `spawnAgent: channel "${action.channel}" not found` };
+            }
+            const label = action.label?.trim() || 'agent';
+            const timeoutMs = spawnCtx.timeoutMs ?? 120_000;
+            const model = action.model ?? spawnCtx.model;
+            try {
+                let text = '';
+                const stream = spawnCtx.runtime.invoke({
+                    prompt: action.prompt,
+                    model,
+                    cwd: spawnCtx.cwd,
+                    timeoutMs,
+                });
+                for await (const event of stream) {
+                    if (event.type === 'text_delta') {
+                        text += event.text;
+                    }
+                    else if (event.type === 'text_final') {
+                        text = event.text;
+                    }
+                    else if (event.type === 'error') {
+                        return { ok: false, error: `spawnAgent (${label}) failed: ${event.message}` };
+                    }
+                }
+                const outputText = text.trim() || `Agent (${label}) completed with no output.`;
+                const chunks = splitDiscord(outputText);
+                for (const chunk of chunks) {
+                    await targetChannel.send({ content: chunk, allowedMentions: NO_MENTIONS });
+                }
+                return {
+                    ok: true,
+                    summary: `Agent (${label}) posted to #${targetChannel.name}`,
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { ok: false, error: `spawnAgent (${label}) failed: ${msg}` };
+            }
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Parallel coordinator
+// ---------------------------------------------------------------------------
+/**
+ * Execute multiple spawnAgent actions in parallel, bounded by maxConcurrent.
+ * Results are returned in the same order as the input actions.
+ */
+export async function executeSpawnActions(actions, ctx, spawnCtx) {
+    if (actions.length === 0)
+        return [];
+    const maxConcurrent = spawnCtx.maxConcurrent ?? 4;
+    const results = new Array(actions.length);
+    let i = 0;
+    while (i < actions.length) {
+        const batch = actions.slice(i, i + maxConcurrent);
+        const settled = await Promise.allSettled(batch.map((action) => executeSpawnAction(action, ctx, spawnCtx)));
+        for (let j = 0; j < settled.length; j++) {
+            const item = settled[j];
+            results[i + j] = item.status === 'fulfilled'
+                ? item.value
+                : { ok: false, error: item.reason instanceof Error ? item.reason.message : String(item.reason) };
+        }
+        i += maxConcurrent;
+    }
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Prompt section
+// ---------------------------------------------------------------------------
+export function spawnActionsPromptSection() {
+    return `### Spawn Agent
+
+**spawnAgent** — Spawn a parallel sub-agent in a target channel:
+\`\`\`
+<discord-action>{"type":"spawnAgent","channel":"general","prompt":"List all open tasks and summarize their status","label":"task-summary"}</discord-action>
+\`\`\`
+- \`channel\` (required): Target channel name or ID where the spawned agent posts its output.
+- \`prompt\` (required): The instruction to send to the sub-agent.
+- \`model\` (optional): Model override for the spawned invocation.
+- \`label\` (optional): A short human-readable label for the agent (used in error messages).
+
+#### Spawn Guidelines
+- Multiple spawnAgent actions in a single response are run in parallel for efficiency.
+- Spawned agents run at recursion depth 1 and cannot themselves spawn further agents.
+- The spawned agent runs fire-and-forget: it posts its output directly to the target channel.
+- Keep prompts focused — each agent handles a single well-defined task.`;
+}

package/dist/discord/actions-spawn.test.js

@@ -0,0 +1,385 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { ChannelType } from 'discord.js';
+import { SPAWN_ACTION_TYPES, executeSpawnAction, executeSpawnActions, spawnActionsPromptSection, } from './actions-spawn.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeMockChannel() {
+    return {
+        id: 'ch-general',
+        name: 'general',
+        type: ChannelType.GuildText,
+        send: vi.fn(async () => ({ id: 'sent-1' })),
+    };
+}
+function makeCtx(channel) {
+    const ch = channel ?? makeMockChannel();
+    return {
+        guild: {
+            channels: {
+                cache: {
+                    get: (id) => id === ch.id ? ch : undefined,
+                    find: (fn) => fn(ch) ? ch : undefined,
+                },
+            },
+        },
+        client: {},
+        channelId: 'test-channel',
+        messageId: 'test-message',
+    };
+}
+function makeRuntime(events) {
+    return {
+        id: 'other',
+        capabilities: new Set(),
+        invoke: vi.fn(async function* () {
+            for (const event of events) {
+                yield event;
+            }
+        }),
+    };
+}
+function makeSpawnCtx(overrides) {
+    return {
+        runtime: makeRuntime([{ type: 'text_delta', text: 'Agent output' }, { type: 'done' }]),
+        model: 'claude-opus-4',
+        cwd: '/tmp/workspace',
+        log: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+        ...overrides,
+    };
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('SPAWN_ACTION_TYPES', () => {
+    it('contains spawnAgent', () => {
+        expect(SPAWN_ACTION_TYPES.has('spawnAgent')).toBe(true);
+    });
+    it('does not contain non-spawn types', () => {
+        expect(SPAWN_ACTION_TYPES.has('forgeCreate')).toBe(false);
+        expect(SPAWN_ACTION_TYPES.has('planRun')).toBe(false);
+        expect(SPAWN_ACTION_TYPES.has('cronCreate')).toBe(false);
+    });
+});
+describe('executeSpawnAction', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('spawnAgent', () => {
+        it('posts agent text output to target channel', async () => {
+            const channel = makeMockChannel();
+            const result = await executeSpawnAction({ type: 'spawnAgent', channel: 'general', prompt: 'Say hello' }, makeCtx(channel), makeSpawnCtx());
+            expect(result.ok).toBe(true);
+            expect(channel.send).toHaveBeenCalledWith(expect.objectContaining({ content: 'Agent output' }));
+        });
+        it('returns summary indicating agent posted to channel', async () => {
+            const channel = makeMockChannel();
+            const result = await executeSpawnAction({ type: 'spawnAgent', channel: 'general', prompt: 'Say hello' }, makeCtx(channel), makeSpawnCtx());
+            expect(result.ok).toBe(true);
+            if (result.ok) {
+                expect(result.summary).toContain('#general');
+            }
+        });
+        it('fails on empty channel', async () => {
+            const result = await executeSpawnAction({ type: 'spawnAgent', channel: '', prompt: 'Do something' }, makeCtx(), makeSpawnCtx());
+            expect(result.ok).toBe(false);
+            if (!result.ok)
+                expect(result.error).toContain('requires a non-empty channel');
+        });
+        it('fails on whitespace-only channel', async () => {
+            const result = await executeSpawnAction({ type: 'spawnAgent', channel: '   ', prompt: 'Do something' }, makeCtx(), makeSpawnCtx());
+            expect(result.ok).toBe(false);
+            if (!result.ok)
+                expect(result.error).toContain('requires a non-empty channel');
+        });
+        it('fails on empty prompt', async () => {
+            const result = await executeSpawnAction({ type: 'spawnAgent', channel: 'general', prompt: '' }, makeCtx(), makeSpawnCtx());
+            expect(result.ok).toBe(false);
+            if (!result.ok)
+                expect(result.error).toContain('requires a non-empty prompt');
+        });
+        it('fails on whitespace-only prompt', async () => {
+            const result = await executeSpawnAction({ type: 'spawnAgent', channel: 'general', prompt: '   ' }, makeCtx(), makeSpawnCtx());
+            expect(result.ok).toBe(false);
+            if (!result.ok)
+                expect(result.error).toContain('requires a non-empty prompt');
+        });
+        it('fails when channel is not found', async () => {
+            const result = await executeSpawnAction({ type: 'spawnAgent', channel: 'nonexistent', prompt: 'Do something' }, makeCtx(), makeSpawnCtx());
+            expect(result.ok).toBe(false);
+            if (!result.ok)
+                expect(result.error).toContain('not found');
+        });
+        it('fails when channel is a non-text type', async () => {
+            const forumChannel = { id: 'ch-forum', name: 'ideas', type: ChannelType.GuildForum, send: vi.fn() };
+            const ctx = {
+                guild: {
+                    channels: {
+                        cache: {
+                            get: (id) => id === forumChannel.id ? forumChannel : undefined,
+                            find: (fn) => fn(forumChannel) ? forumChannel : undefined,
+                        },
+                    },
+                },
+                client: {},
+                channelId: 'test-channel',
+                messageId: 'test-message',
+            };
+            const result = await executeSpawnAction({ type: 'spawnAgent', channel: 'ideas', prompt: 'Do something' }, ctx, makeSpawnCtx());
+            expect(result.ok).toBe(false);
+            if (!result.ok) {
+                expect(result.error).toContain('forum');
+            }
+        });
+        it('blocks at recursion depth >= 1', async () => {
+            const result = await executeSpawnAction({ type: 'spawnAgent', channel: 'general', prompt: 'Do something' }, makeCtx(), makeSpawnCtx({ depth: 1 }));
+            expect(result.ok).toBe(false);
+            if (!result.ok)
+                expect(result.error).toContain('recursion depth');
+        });
+        it('uses label in error messages on runtime error event', async () => {
+            const runtime = makeRuntime([{ type: 'error', message: 'Runtime error' }]);
+            const result = await executeSpawnAction({ type: 'spawnAgent', channel: 'general', prompt: 'Do something', label: 'my-agent' }, makeCtx(), makeSpawnCtx({ runtime }));
+            expect(result.ok).toBe(false);
+            if (!result.ok) {
+                expect(result.error).toContain('my-agent');
+                expect(result.error).toContain('Runtime error');
+            }
+        });
+        it('prefers text_final over accumulated text_delta and posts to channel', async () => {
+            const runtime = makeRuntime([
+                { type: 'text_delta', text: 'partial ' },
+                { type: 'text_delta', text: 'output' },
+                { type: 'text_final', text: 'Final output' },
+                { type: 'done' },
+            ]);
+            const channel = makeMockChannel();
+            const result = await executeSpawnAction({ type: 'spawnAgent', channel: 'general', prompt: 'Do something' }, makeCtx(channel), makeSpawnCtx({ runtime }));
+            expect(result.ok).toBe(true);
+            expect(channel.send).toHaveBeenCalledWith(expect.objectContaining({ content: 'Final output' }));
+        });
+        it('accumulates multiple text_delta events and posts combined text to channel', async () => {
+            const runtime = makeRuntime([
+                { type: 'text_delta', text: 'Hello ' },
+                { type: 'text_delta', text: 'world' },
+                { type: 'done' },
+            ]);
+            const channel = makeMockChannel();
+            const result = await executeSpawnAction({ type: 'spawnAgent', channel: 'general', prompt: 'Greet' }, makeCtx(channel), makeSpawnCtx({ runtime }));
+            expect(result.ok).toBe(true);
+            expect(channel.send).toHaveBeenCalledWith(expect.objectContaining({ content: 'Hello world' }));
+        });
+        it('handles runtime throw as error result', async () => {
+            const runtime = {
+                id: 'other',
+                capabilities: new Set(),
+                invoke: vi.fn(async function* () {
+                    throw new Error('connection failed');
+                }),
+            };
+            const result = await executeSpawnAction({ type: 'spawnAgent', channel: 'general', prompt: 'Do something' }, makeCtx(), makeSpawnCtx({ runtime }));
+            expect(result.ok).toBe(false);
+            if (!result.ok)
+                expect(result.error).toContain('connection failed');
+        });
+        it('posts fallback message with label to channel when agent outputs nothing', async () => {
+            const runtime = makeRuntime([{ type: 'done' }]);
+            const channel = makeMockChannel();
+            const result = await executeSpawnAction({ type: 'spawnAgent', channel: 'general', prompt: 'Do something', label: 'silent-agent' }, makeCtx(channel), makeSpawnCtx({ runtime }));
+            expect(result.ok).toBe(true);
+            expect(channel.send).toHaveBeenCalledWith(expect.objectContaining({ content: expect.stringContaining('silent-agent') }));
+            expect(channel.send).toHaveBeenCalledWith(expect.objectContaining({ content: expect.stringContaining('no output') }));
+        });
+        it('uses "agent" as default label in fallback message', async () => {
+            const runtime = makeRuntime([{ type: 'done' }]);
+            const channel = makeMockChannel();
+            const result = await executeSpawnAction({ type: 'spawnAgent', channel: 'general', prompt: 'Do something' }, makeCtx(channel), makeSpawnCtx({ runtime }));
+            expect(result.ok).toBe(true);
+            expect(channel.send).toHaveBeenCalledWith(expect.objectContaining({ content: expect.stringContaining('agent') }));
+        });
+        it('invokes runtime with correct model, cwd, and prompt', async () => {
+            const runtime = makeRuntime([{ type: 'done' }]);
+            const spawnCtx = makeSpawnCtx({ runtime, model: 'claude-opus-4-6', cwd: '/my/cwd' });
+            await executeSpawnAction({ type: 'spawnAgent', channel: 'general', prompt: 'Do something specific' }, makeCtx(), spawnCtx);
+            expect(runtime.invoke).toHaveBeenCalledWith(expect.objectContaining({
+                model: 'claude-opus-4-6',
+                cwd: '/my/cwd',
+                prompt: 'Do something specific',
+            }));
+        });
+        it('action.model overrides spawnCtx.model', async () => {
+            const runtime = makeRuntime([{ type: 'done' }]);
+            const spawnCtx = makeSpawnCtx({ runtime, model: 'claude-haiku-4-5-20251001' });
+            await executeSpawnAction({ type: 'spawnAgent', channel: 'general', prompt: 'Task', model: 'claude-opus-4-6' }, makeCtx(), spawnCtx);
+            expect(runtime.invoke).toHaveBeenCalledWith(expect.objectContaining({ model: 'claude-opus-4-6' }));
+        });
+        it('passes timeoutMs to runtime invocation', async () => {
+            const runtime = makeRuntime([{ type: 'done' }]);
+            const spawnCtx = makeSpawnCtx({ runtime, timeoutMs: 30_000 });
+            await executeSpawnAction({ type: 'spawnAgent', channel: 'general', prompt: 'Quick task' }, makeCtx(), spawnCtx);
+            expect(runtime.invoke).toHaveBeenCalledWith(expect.objectContaining({ timeoutMs: 30_000 }));
+        });
+        it('uses default timeout of 120_000 when not specified', async () => {
+            const runtime = makeRuntime([{ type: 'done' }]);
+            const spawnCtx = makeSpawnCtx({ runtime });
+            await executeSpawnAction({ type: 'spawnAgent', channel: 'general', prompt: 'Task' }, makeCtx(), spawnCtx);
+            expect(runtime.invoke).toHaveBeenCalledWith(expect.objectContaining({ timeoutMs: 120_000 }));
+        });
+        it('posts output without allowed mentions', async () => {
+            const channel = makeMockChannel();
+            const result = await executeSpawnAction({ type: 'spawnAgent', channel: 'general', prompt: 'Say hello' }, makeCtx(channel), makeSpawnCtx());
+            expect(result.ok).toBe(true);
+            expect(channel.send).toHaveBeenCalledWith(expect.objectContaining({ allowedMentions: expect.objectContaining({ parse: [] }) }));
+        });
+        it('handles channel.send error as error result', async () => {
+            const channel = { ...makeMockChannel(), send: vi.fn(async () => { throw new Error('Missing Access'); }) };
+            const result = await executeSpawnAction({ type: 'spawnAgent', channel: 'general', prompt: 'Do something' }, makeCtx(channel), makeSpawnCtx());
+            expect(result.ok).toBe(false);
+            if (!result.ok)
+                expect(result.error).toContain('Missing Access');
+        });
+    });
+});
+describe('executeSpawnActions', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('returns empty array for no actions', async () => {
+        const results = await executeSpawnActions([], makeCtx(), makeSpawnCtx());
+        expect(results).toEqual([]);
+    });
+    it('runs a single agent and returns its result', async () => {
+        const results = await executeSpawnActions([{ type: 'spawnAgent', channel: 'general', prompt: 'Single task' }], makeCtx(), makeSpawnCtx());
+        expect(results).toHaveLength(1);
+        expect(results[0].ok).toBe(true);
+    });
+    it('runs multiple agents and returns results in order', async () => {
+        let callCount = 0;
+        const runtime = {
+            id: 'other',
+            capabilities: new Set(),
+            invoke: vi.fn(async function* () {
+                const n = ++callCount;
+                yield { type: 'text_delta', text: `result-${n}` };
+                yield { type: 'done' };
+            }),
+        };
+        const spawnCtx = makeSpawnCtx({ runtime });
+        const results = await executeSpawnActions([
+            { type: 'spawnAgent', channel: 'general', prompt: 'First task' },
+            { type: 'spawnAgent', channel: 'general', prompt: 'Second task' },
+            { type: 'spawnAgent', channel: 'general', prompt: 'Third task' },
+        ], makeCtx(), spawnCtx);
+        expect(results).toHaveLength(3);
+        expect(results.every((r) => r.ok)).toBe(true);
+    });
+    it('respects maxConcurrent limit per batch', async () => {
+        let concurrentCount = 0;
+        let maxSeen = 0;
+        const runtime = {
+            id: 'other',
+            capabilities: new Set(),
+            invoke: vi.fn(async function* () {
+                concurrentCount++;
+                maxSeen = Math.max(maxSeen, concurrentCount);
+                yield { type: 'text_delta', text: 'ok' };
+                yield { type: 'done' };
+                concurrentCount--;
+            }),
+        };
+        await executeSpawnActions(Array.from({ length: 8 }, (_, i) => ({ type: 'spawnAgent', channel: 'general', prompt: `Task ${i}` })), makeCtx(), makeSpawnCtx({ runtime, maxConcurrent: 3 }));
+        expect(maxSeen).toBeLessThanOrEqual(3);
+    });
+    it('uses default maxConcurrent of 4', async () => {
+        let concurrentCount = 0;
+        let maxSeen = 0;
+        const runtime = {
+            id: 'other',
+            capabilities: new Set(),
+            invoke: vi.fn(async function* () {
+                concurrentCount++;
+                maxSeen = Math.max(maxSeen, concurrentCount);
+                yield { type: 'text_delta', text: 'ok' };
+                yield { type: 'done' };
+                concurrentCount--;
+            }),
+        };
+        await executeSpawnActions(Array.from({ length: 10 }, (_, i) => ({ type: 'spawnAgent', channel: 'general', prompt: `Task ${i}` })), makeCtx(), makeSpawnCtx({ runtime }));
+        expect(maxSeen).toBeLessThanOrEqual(4);
+    });
+    it('collects errors without aborting other agents', async () => {
+        let callIndex = 0;
+        const runtime = {
+            id: 'other',
+            capabilities: new Set(),
+            invoke: vi.fn(async function* () {
+                const i = callIndex++;
+                if (i === 1) {
+                    yield { type: 'error', message: 'agent-1 failed' };
+                }
+                else {
+                    yield { type: 'text_delta', text: `result-${i}` };
+                    yield { type: 'done' };
+                }
+            }),
+        };
+        const results = await executeSpawnActions([
+            { type: 'spawnAgent', channel: 'general', prompt: 'First' },
+            { type: 'spawnAgent', channel: 'general', prompt: 'Second' },
+            { type: 'spawnAgent', channel: 'general', prompt: 'Third' },
+        ], makeCtx(), makeSpawnCtx({ runtime }));
+        expect(results).toHaveLength(3);
+        expect(results[0].ok).toBe(true);
+        expect(results[1].ok).toBe(false);
+        if (!results[1].ok)
+            expect(results[1].error).toContain('agent-1 failed');
+        expect(results[2].ok).toBe(true);
+    });
+    it('all results are ok: false when depth >= 1 (recursion guard)', async () => {
+        const results = await executeSpawnActions([
+            { type: 'spawnAgent', channel: 'general', prompt: 'First' },
+            { type: 'spawnAgent', channel: 'general', prompt: 'Second' },
+        ], makeCtx(), makeSpawnCtx({ depth: 1 }));
+        expect(results).toHaveLength(2);
+        expect(results.every((r) => !r.ok)).toBe(true);
+        for (const r of results) {
+            if (!r.ok)
+                expect(r.error).toContain('recursion depth');
+        }
+    });
+});
+describe('spawnActionsPromptSection', () => {
+    it('returns non-empty prompt section containing spawnAgent', () => {
+        const section = spawnActionsPromptSection();
+        expect(section).toContain('spawnAgent');
+    });
+    it('documents the channel field', () => {
+        const section = spawnActionsPromptSection();
+        expect(section).toContain('channel');
+    });
+    it('documents the prompt field', () => {
+        const section = spawnActionsPromptSection();
+        expect(section).toContain('prompt');
+    });
+    it('documents the model field', () => {
+        const section = spawnActionsPromptSection();
+        expect(section).toContain('model');
+    });
+    it('documents the label field', () => {
+        const section = spawnActionsPromptSection();
+        expect(section).toContain('label');
+    });
+    it('mentions parallel execution', () => {
+        const section = spawnActionsPromptSection();
+        expect(section).toContain('parallel');
+    });
+    it('mentions recursion depth guard', () => {
+        const section = spawnActionsPromptSection();
+        expect(section).toContain('recursion');
+    });
+    it('includes a usage example block', () => {
+        const section = spawnActionsPromptSection();
+        expect(section).toContain('<discord-action>');
+        expect(section).toContain('spawnAgent');
+    });
+});

package/dist/discord/actions.js

@@ -14,6 +14,7 @@ import { CONFIG_ACTION_TYPES, executeConfigAction, configActionsPromptSection }
 import { executeReactionPromptAction as executeReactionPrompt, REACTION_PROMPT_ACTION_TYPES, reactionPromptSection } from './reaction-prompts.js';
 import { IMAGEGEN_ACTION_TYPES, executeImagegenAction, imagegenActionsPromptSection } from './actions-imagegen.js';
 import { VOICE_ACTION_TYPES, executeVoiceAction, voiceActionsPromptSection } from './actions-voice.js';
+import { SPAWN_ACTION_TYPES, executeSpawnActions, spawnActionsPromptSection } from './actions-spawn.js';
 import { describeDestructiveConfirmationRequirement } from './destructive-confirmation.js';
 // ---------------------------------------------------------------------------
 // Valid types (union of all sub-module type sets)
@@ -68,6 +69,9 @@ function buildValidTypes(flags) {
     if (flags.voice)
         for (const t of VOICE_ACTION_TYPES)
             types.add(t);
+    if (flags.spawn)
+        for (const t of SPAWN_ACTION_TYPES)
+            types.add(t);
     return types;
 }
 function rewriteLegacyPlanCloseToTaskClose(parsed, flags) {
@@ -421,9 +425,37 @@ export function parseDiscordActions(text, flags) {
 // ---------------------------------------------------------------------------
 export async function executeDiscordActions(actions, ctx, log, subs) {
     const effectiveSubs = subs ?? {};
+    // --- Spawn pre-pass: collect all spawnAgent actions and run in parallel ---
+    const spawnResultByIndex = new Map();
+    if (effectiveSubs.spawnCtx) {
+        const spawnActions = [];
+        const spawnIndices = [];
+        for (let i = 0; i < actions.length; i++) {
+            if (SPAWN_ACTION_TYPES.has(actions[i].type)) {
+                spawnActions.push(actions[i]);
+                spawnIndices.push(i);
+            }
+        }
+        if (spawnActions.length > 0) {
+            const spawnResults = await executeSpawnActions(spawnActions, ctx, effectiveSubs.spawnCtx);
+            for (let i = 0; i < spawnIndices.length; i++) {
+                spawnResultByIndex.set(spawnIndices[i], spawnResults[i]);
+            }
+        }
+    }
     const results = [];
-    for (const action of actions) {
+    for (let actionIdx = 0; actionIdx < actions.length; actionIdx++) {
+        const action = actions[actionIdx];
         try {
+            // Spawn actions were executed in parallel in the pre-pass above.
+            if (spawnResultByIndex.has(actionIdx)) {
+                const result = spawnResultByIndex.get(actionIdx);
+                results.push(result);
+                if (result.ok) {
+                    log?.info({ action: action.type, summary: result.summary }, `discord:action ${action.type}`);
+                }
+                continue;
+            }
             let result;
             const destructiveCheck = describeDestructiveConfirmationRequirement(action, ctx.confirmation);
             if (!destructiveCheck.allow) {
@@ -520,6 +552,10 @@ export async function executeDiscordActions(actions, ctx, log, subs) {
                     result = await executeVoiceAction(action, ctx, effectiveSubs.voiceCtx);
                 }
             }
+            else if (SPAWN_ACTION_TYPES.has(action.type)) {
+                // spawnCtx not configured — would have been handled in pre-pass otherwise.
+                result = { ok: false, error: 'Spawn subsystem not configured' };
+            }
             else {
                 result = { ok: false, error: `Unknown action type: ${String(action.type ?? 'unknown')}` };
             }
@@ -547,7 +583,7 @@ export async function executeDiscordActions(actions, ctx, log, subs) {
 export function buildDisplayResultLines(actions, results) {
     return results
         .map((r, i) => {
-        if (r.ok && (actions[i]?.type === 'sendMessage' || actions[i]?.type === 'sendFile'))
+        if (r.ok && (actions[i]?.type === 'sendMessage' || actions[i]?.type === 'sendFile' || actions[i]?.type === 'spawnAgent'))
             return null;
         return r.ok ? `Done: ${r.summary}` : `Failed: ${r.error}`;
     })
@@ -611,6 +647,9 @@ Setting DISCOCLAW_DISCORD_ACTIONS=1 publishes this standard guidance (even if on
     if (flags.voice) {
         sections.push(voiceActionsPromptSection());
     }
+    if (flags.spawn) {
+        sections.push(spawnActionsPromptSection());
+    }
     sections.push(`### Rules
 - Only the action types listed above are supported.
 - Never emit an action with empty, placeholder, or missing values for required parameters. If you don't have the value (e.g., no messageId for react), skip the action entirely.

package/dist/discord/message-coordinator.js

@@ -341,6 +341,7 @@ export function createMessageCreateHandler(params, queue, statusRef) {
                 defer: !isDm && (params.discordActionsDefer ?? false),
                 imagegen: params.discordActionsImagegen ?? false,
                 voice: params.discordActionsVoice ?? false,
+                spawn: params.discordActionsSpawn ?? false,
             };
             if (isBotMessage) {
                 actionFlags.channels = false;
@@ -356,6 +357,7 @@ export function createMessageCreateHandler(params, queue, statusRef) {
                 actionFlags.tasks = false;
                 actionFlags.imagegen = false;
                 actionFlags.voice = false;
+                actionFlags.spawn = false;
                 actionFlags.polls = false;
                 actionFlags.messaging = true;
             }
@@ -1719,6 +1721,7 @@ export function createMessageCreateHandler(params, queue, statusRef) {
                             configCtx: params.configCtx,
                             imagegenCtx: params.imagegenCtx,
                             voiceCtx: params.voiceCtx,
+                            spawnCtx: params.spawnCtx,
                         });
                         const displayLines = buildDisplayResultLines([confirmAction], actionResults);
                         const content = displayLines.length > 0
@@ -2247,6 +2250,7 @@ export function createMessageCreateHandler(params, queue, statusRef) {
                                         configCtx: params.configCtx,
                                         imagegenCtx: params.imagegenCtx,
                                         voiceCtx: params.voiceCtx,
+                                        spawnCtx: params.spawnCtx,
                                     });
                                     for (const result of actionResults) {
                                         metrics.recordActionResult(result.ok);

package/dist/discord/reaction-handler.js

@@ -322,6 +322,7 @@ function createReactionHandler(mode, params, queue, statusRef) {
                         defer: !isDm && (params.discordActionsDefer ?? false),
                         imagegen: params.discordActionsImagegen ?? false,
                         voice: params.discordActionsVoice ?? false,
+                        spawn: params.discordActionsSpawn ?? false,
                     };
                     if (params.discordActionsEnabled && !isDm) {
                         prompt += '\n\n---\n' + discordActionsPromptSection(actionFlags, params.botDisplayName);
@@ -554,6 +555,7 @@ function createReactionHandler(mode, params, queue, statusRef) {
                                         configCtx: params.configCtx,
                                         imagegenCtx: params.imagegenCtx,
                                         voiceCtx: params.voiceCtx,
+                                        spawnCtx: params.spawnCtx,
                                     });
                                     actionResults = results;
                                     for (const result of results) {

package/dist/discord/update-command.js

@@ -97,7 +97,7 @@ export async function handleUpdateCommand(cmd, opts = {}) {
     }
     if (npmMode) {
         progress('Installing latest version from npm...');
-        const install = await run('npm', ['install', '-g', 'discoclaw@latest'], { timeout: 120_000 });
+        const install = await run('npm', ['install', '-g', 'discoclaw@latest', '--loglevel=error'], { timeout: 120_000 });
         if (install.exitCode !== 0) {
             const detail = (install.stderr || install.stdout).trim().slice(0, 500);
             return { reply: `\`npm install -g discoclaw@latest\` failed:\n\`\`\`\n${detail}\n\`\`\`` };

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

@@ -334,6 +334,7 @@ describe('handleUpdateCommand: npm-managed mode', () => {
         const calls = execFile.mock.calls;
         const installCall = calls.find(([cmd, args]) => cmd === 'npm' && args.includes('install') && args.includes('discoclaw@latest'));
         expect(installCall).toBeDefined();
+        expect(installCall[1]).toContain('--loglevel=error');
     });
     it('apply reports error on install failure', async () => {
         const { execFile } = await import('node:child_process');

package/dist/index.js

@@ -724,6 +724,7 @@ const botParams = {
     discordActionsMemory: discordActionsMemory && durableMemoryEnabled,
     discordActionsImagegen: cfg.discordActionsImagegen,
     discordActionsVoice: cfg.discordActionsVoice && cfg.voiceEnabled,
+    discordActionsSpawn: cfg.discordActionsSpawn,
     discordActionsConfig: discordActionsEnabled, // Always enabled when actions are on — model switching is a core capability.
     discordActionsDefer: cfg.discordActionsDefer,
     deferMaxDelaySeconds: cfg.deferMaxDelaySeconds,
@@ -735,6 +736,7 @@ const botParams = {
     planCtx: undefined,
     memoryCtx: undefined,
     imagegenCtx: undefined,
+    spawnCtx: undefined,
     voiceCtx: undefined,
     voiceStatusCtx: undefined,
     setTtsVoice: undefined,
@@ -1091,6 +1093,16 @@ if (taskCtx) {
         };
         log.info('imagegen:action context initialized');
     }
+    if (discordActionsEnabled && cfg.discordActionsSpawn) {
+        botParams.spawnCtx = {
+            runtime: limitedRuntime,
+            model: runtimeModel,
+            cwd: workspaceCwd,
+            log,
+            maxConcurrent: cfg.spawnMaxConcurrent,
+        };
+        log.info({ maxConcurrent: cfg.spawnMaxConcurrent }, 'spawn:action context initialized');
+    }
     if (cfg.voiceEnabled) {
         const voiceLogChannelRef = cfg.voiceLogChannel ?? system?.voiceLogChannelId;
         const transcriptMirror = voiceLogChannelRef
@@ -1269,6 +1281,7 @@ if (taskCtx) {
                 deepgramApiKey: cfg.deepgramApiKey,
                 deepgramSttModel: cfg.deepgramSttModel,
                 deepgramTtsVoice: overrides.ttsVoice ?? cfg.deepgramTtsVoice,
+                deepgramTtsSpeed: cfg.deepgramTtsSpeed,
                 cartesiaApiKey: cfg.cartesiaApiKey,
                 openaiApiKey: cfg.openaiApiKey,
             },
@@ -1354,6 +1367,7 @@ if (cronEnabled && effectiveCronForum) {
         defer: false,
         imagegen: Boolean(botParams.imagegenCtx), // Follows env flag (DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN + API key) — cron jobs may generate images if explicitly configured.
         voice: Boolean(botParams.voiceCtx), // Follows env flag (DISCOCLAW_DISCORD_ACTIONS_VOICE + VOICE_ENABLED) — cron jobs may use voice if configured.
+        spawn: false, // Spawn is excluded from cron flows to prevent recursive agent spawning from scheduled jobs.
     };
     const cronRunControl = new CronRunControl();
     // Load cron tag map (strict, but fallback to empty on first run)

package/dist/npm-managed.js

@@ -48,7 +48,7 @@ export async function getLatestNpmVersion() {
  */
 export async function npmGlobalUpgrade() {
     try {
-        const result = await execa('npm', ['install', '-g', 'discoclaw'], {
+        const result = await execa('npm', ['install', '-g', 'discoclaw', '--loglevel=error'], {
             timeout: 120_000,
         });
         return {

package/dist/npm-managed.test.js

@@ -81,7 +81,7 @@ describe('npmGlobalUpgrade', () => {
         expect(result.exitCode).toBe(0);
         expect(result.stdout).toBe('added discoclaw@1.2.3');
         expect(result.stderr).toBe('');
-        expect(mockExeca).toHaveBeenCalledWith('npm', ['install', '-g', 'discoclaw'], {
+        expect(mockExeca).toHaveBeenCalledWith('npm', ['install', '-g', 'discoclaw', '--loglevel=error'], {
             timeout: 120_000,
         });
     });

package/dist/voice/tts-deepgram.js

@@ -12,12 +12,17 @@ export class DeepgramTtsProvider {
     apiKey;
     model;
     sampleRate;
+    speed;
     log;
     fetchFn;
     constructor(opts) {
+        if (opts.speed !== undefined && (opts.speed < 0.5 || opts.speed > 1.5)) {
+            throw new RangeError(`DeepgramTtsProvider: speed must be in range [0.5, 1.5], got ${opts.speed}`);
+        }
         this.apiKey = opts.apiKey;
         this.model = opts.model ?? DEFAULT_MODEL;
         this.sampleRate = opts.sampleRate ?? DEFAULT_SAMPLE_RATE;
+        this.speed = opts.speed;
         this.log = opts.log;
         this.fetchFn = opts.fetchFn ?? globalThis.fetch;
     }
@@ -37,6 +42,9 @@ export class DeepgramTtsProvider {
             sample_rate: String(this.sampleRate),
             container: 'none',
         });
+        if (this.speed !== undefined) {
+            params.set('speed', String(this.speed));
+        }
         const url = `${DEEPGRAM_SPEECH_URL}?${params.toString()}`;
         this.log.info({ model: this.model, textLength: text.length }, 'Deepgram TTS: sending synthesis request');
         const response = await this.fetchFn(url, {

package/dist/voice/tts-deepgram.test.js

@@ -34,6 +34,7 @@ function makeProvider(overrides = {}) {
         apiKey: overrides.apiKey ?? 'test-key',
         model: overrides.model,
         sampleRate: overrides.sampleRate,
+        speed: overrides.speed,
         log: overrides.log ?? createLogger(),
         fetchFn: overrides.fetchFn ?? mockFetch(),
     });
@@ -183,6 +184,28 @@ describe('DeepgramTtsProvider', () => {
             expect(log.warn).not.toHaveBeenCalled();
         });
     });
+    describe('speed parameter', () => {
+        it('includes speed in the URL when set', async () => {
+            const fetchFn = mockFetch([new Uint8Array([1])]);
+            const provider = makeProvider({ fetchFn, speed: 1.2 });
+            await collectFrames(provider.synthesize('hello'));
+            const [url] = vi.mocked(fetchFn).mock.calls[0];
+            expect(url).toContain('speed=1.2');
+        });
+        it('omits speed from the URL when not set', async () => {
+            const fetchFn = mockFetch([new Uint8Array([1])]);
+            const provider = makeProvider({ fetchFn });
+            await collectFrames(provider.synthesize('hello'));
+            const [url] = vi.mocked(fetchFn).mock.calls[0];
+            expect(url).not.toContain('speed=');
+        });
+        it('throws RangeError when speed is below 0.5', () => {
+            expect(() => makeProvider({ speed: 0.4 })).toThrow(RangeError);
+        });
+        it('throws RangeError when speed is above 1.5', () => {
+            expect(() => makeProvider({ speed: 1.6 })).toThrow(RangeError);
+        });
+    });
     it('single large chunk yields one frame', async () => {
         const big = new Uint8Array(16384);
         big.fill(42);

package/dist/voice/tts-factory.js

@@ -30,6 +30,7 @@ export function createTtsProvider(config, log) {
             return new DeepgramTtsProvider({
                 apiKey: config.deepgramApiKey,
                 model: config.deepgramTtsVoice,
+                speed: config.deepgramTtsSpeed,
                 log,
             });
         }

package/dist/voice/voice-style-prompt.js

@@ -10,4 +10,5 @@
 export const VOICE_STYLE_INSTRUCTION = 'Telegraphic style: answer first, explain after only if needed. ' +
     'No markdown (no bullets, headers, bold, code blocks). ' +
     'No preambles ("Great question", "Sure", "Of course"). ' +
-    'No filler. Short sentences. One idea per sentence.';
+    'No filler. Short sentences. One idea per sentence. ' +
+    'Never read codes, IDs, or hashes verbatim — describe what they refer to instead.';

package/dist/voice/voice-style-prompt.test.js

@@ -17,4 +17,8 @@ describe('VOICE_STYLE_INSTRUCTION', () => {
     it('contains key term "no markdown"', () => {
         expect(VOICE_STYLE_INSTRUCTION.toLowerCase()).toContain('no markdown');
     });
+    it('contains key term "codes" or "IDs"', () => {
+        const lower = VOICE_STYLE_INSTRUCTION.toLowerCase();
+        expect(lower.includes('codes') || lower.includes('ids')).toBe(true);
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discoclaw",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Minimal Discord bridge routing messages to AI runtimes",
   "license": "MIT",
   "repository": {