beecork 1.4.11 → 1.5.0

package/dist/channels/types.d.ts

@@ -1,14 +1,6 @@
 import type { TabManager } from '../session/manager.js';
-import type { BeecorkConfig } from '../types.js';
-/** A media file attached to a message */
-export interface MediaAttachment {
-    type: 'image' | 'audio' | 'video' | 'document' | 'voice';
-    mimeType: string;
-    filePath: string;
-    fileName?: string;
-    duration?: number;
-    caption?: string;
-}
+import type { BeecorkConfig, MediaAttachment } from '../types.js';
+export type { MediaAttachment };
 /** An inbound message from any channel */
 export interface InboundMessage {
     channelId: string;

package/dist/channels/voice-state.d.ts

@@ -0,0 +1,29 @@
+import type { STTProvider } from '../voice/stt.js';
+import type { TTSProvider } from '../voice/tts.js';
+import type { VoiceConfig, BeecorkConfig } from '../types.js';
+import type { MediaAttachment } from '../types.js';
+/**
+ * Per-channel STT/TTS state. Used to be duplicated across Telegram, WhatsApp,
+ * and Discord; consolidated here so init + warmup + transcription happen the
+ * same way across all 3.
+ *
+ * Discord historically only called warmup() and did NOT transcribe — preserve
+ * that behavior unless the caller explicitly asks for transcription.
+ */
+export declare class VoiceState {
+    private readonly channelId;
+    stt: STTProvider | null;
+    tts: TTSProvider | null;
+    private warmedUp;
+    constructor(channelId: string);
+    init(config: BeecorkConfig | {
+        voice?: VoiceConfig;
+    }): void;
+    /** One-shot warmup (no media). Used by Discord today. */
+    warmup(): Promise<void>;
+    /**
+     * Transcribe voice attachments in-place (mutates the caption fields).
+     * Returns the updated warmed-up flag. No-op if STT isn't configured.
+     */
+    transcribe(media: MediaAttachment[]): Promise<void>;
+}

package/dist/channels/voice-state.js

@@ -0,0 +1,43 @@
+import { initVoiceProviders } from '../voice/index.js';
+/**
+ * Per-channel STT/TTS state. Used to be duplicated across Telegram, WhatsApp,
+ * and Discord; consolidated here so init + warmup + transcription happen the
+ * same way across all 3.
+ *
+ * Discord historically only called warmup() and did NOT transcribe — preserve
+ * that behavior unless the caller explicitly asks for transcription.
+ */
+export class VoiceState {
+    channelId;
+    stt = null;
+    tts = null;
+    warmedUp = false;
+    constructor(channelId) {
+        this.channelId = channelId;
+    }
+    init(config) {
+        const { stt, tts } = initVoiceProviders(config.voice);
+        this.stt = stt;
+        this.tts = tts;
+    }
+    /** One-shot warmup (no media). Used by Discord today. */
+    async warmup() {
+        if (this.warmedUp || !this.stt)
+            return;
+        try {
+            this.stt.warmup?.();
+        }
+        catch { /* warmup is best-effort */ }
+        this.warmedUp = true;
+    }
+    /**
+     * Transcribe voice attachments in-place (mutates the caption fields).
+     * Returns the updated warmed-up flag. No-op if STT isn't configured.
+     */
+    async transcribe(media) {
+        if (!this.stt)
+            return;
+        const { transcribeVoiceMessages } = await import('../voice/index.js');
+        this.warmedUp = await transcribeVoiceMessages(media, this.stt, this.channelId, this.warmedUp);
+    }
+}

package/dist/channels/webhook.d.ts

@@ -2,7 +2,7 @@ import type { Channel, ChannelContext, InboundMessageHandler, SendOptions } from
 export declare class WebhookChannel implements Channel {
     readonly id = "webhook";
     readonly name = "Webhook";
-    readonly maxMessageLength = 100000;
+    readonly maxMessageLength: 100000;
     readonly supportsStreaming = false;
     readonly supportsMedia = false;
     private server;

package/dist/channels/webhook.js

@@ -1,11 +1,26 @@
 import http from 'node:http';
 import crypto from 'node:crypto';
 import { logger } from '../util/logger.js';
-import { validateTabName } from '../config.js';
+import { validateTabNameOrDefault } from '../config.js';
+import { inboundLimiter } from '../util/rate-limiter.js';
+import { MESSAGE_LIMITS } from '../util/text.js';
+import { processInboundMessage } from './pipeline.js';
+function safeEqualString(a, b) {
+    const ab = Buffer.from(a);
+    const bb = Buffer.from(b);
+    if (ab.length !== bb.length)
+        return false;
+    try {
+        return crypto.timingSafeEqual(ab, bb);
+    }
+    catch {
+        return false;
+    }
+}
 export class WebhookChannel {
     id = 'webhook';
     name = 'Webhook';
-    maxMessageLength = 100000; // Webhooks can handle large payloads
+    maxMessageLength = MESSAGE_LIMITS.WEBHOOK_PROMPT;
     supportsStreaming = false;
     supportsMedia = false;
     server = null;
@@ -40,22 +55,21 @@ export class WebhookChannel {
                 return;
             }
             const tabName = decodeURIComponent(match[1]);
-            // Validate tab name
-            if (tabName !== 'default') {
-                const tabError = validateTabName(tabName);
-                if (tabError) {
-                    res.writeHead(400);
-                    res.end(JSON.stringify({ error: tabError }));
-                    return;
-                }
+            // Validate tab name (allow "default" — it's a reference, not a creation)
+            const tabError = validateTabNameOrDefault(tabName);
+            if (tabError) {
+                res.writeHead(400);
+                res.end(JSON.stringify({ error: tabError }));
+                return;
             }
             // Read body first (needed for both JSON parsing and HMAC verification)
             let body = '';
             for await (const chunk of req) {
                 body += chunk;
-                if (body.length > 1024 * 1024) { // 1MB limit
+                if (body.length > MESSAGE_LIMITS.HTTP_BODY) {
                     res.writeHead(413);
                     res.end(JSON.stringify({ error: 'Payload too large' }));
+                    req.destroy();
                     return;
                 }
             }
@@ -65,6 +79,12 @@ export class WebhookChannel {
                 res.end(JSON.stringify({ error: 'Unauthorized' }));
                 return;
             }
+            // Rate-limit AFTER auth so unauthenticated callers don't burn the budget
+            if (!inboundLimiter.check(this.id)) {
+                res.writeHead(429);
+                res.end(JSON.stringify({ error: 'Rate limit exceeded' }));
+                return;
+            }
             let payload;
             try {
                 payload = JSON.parse(body);
@@ -81,23 +101,47 @@ export class WebhookChannel {
                 return;
             }
             const isSync = payload.sync ?? false;
+            const remote = req.socket.remoteAddress ?? 'webhook';
             try {
                 if (isSync) {
-                    // Sync mode: wait for Claude response
-                    const result = await this.ctx.tabManager.sendMessage(tabName, prompt);
-                    res.writeHead(result.error ? 500 : 200);
+                    // Sync mode: route through the shared pipeline so routing/enrichment apply.
+                    const result = await processInboundMessage({
+                        text: prompt,
+                        media: [],
+                        channelId: this.id,
+                        tabManager: this.ctx.tabManager,
+                        userId: remote,
+                        sendProgress: () => { },
+                        overrideTabName: tabName,
+                    });
+                    res.writeHead(result.isError ? 500 : 200);
                     res.end(JSON.stringify({
-                        text: result.text,
-                        tab: tabName,
-                        costUsd: result.costUsd,
-                        durationMs: result.durationMs,
-                        error: result.error,
+                        text: result.responseText,
+                        tab: result.tabName,
+                        error: result.isError ? result.responseText : undefined,
                     }));
                 }
                 else {
-                    // Async mode: accept and process in background
-                    this.ctx.tabManager.sendMessage(tabName, prompt).catch(err => {
+                    // Async mode: fire-and-forget through the pipeline.
+                    // Surface failures to the user via broadcastNotify since the HTTP response
+                    // is already 202 and the caller has no other way to learn.
+                    processInboundMessage({
+                        text: prompt,
+                        media: [],
+                        channelId: this.id,
+                        tabManager: this.ctx.tabManager,
+                        userId: remote,
+                        sendProgress: () => { },
+                        overrideTabName: tabName,
+                    }).then(result => {
+                        if (result.isError && this.ctx.notifyCallback) {
+                            this.ctx.notifyCallback(`Webhook async failed for "${tabName}": ${result.responseText}`).catch(() => { });
+                        }
+                    }).catch(err => {
                         logger.error(`Webhook async processing failed for tab ${tabName}:`, err);
+                        if (this.ctx.notifyCallback) {
+                            this.ctx.notifyCallback(`Webhook async failed for "${tabName}": ${err instanceof Error ? err.message : String(err)}`).catch(() => { });
+                        }
                     });
                     res.writeHead(202);
                     res.end(JSON.stringify({ accepted: true, tab: tabName }));
@@ -136,10 +180,10 @@ export class WebhookChannel {
         // No auth configured = allow all (localhost only)
         if (!config.authToken && !config.hmacSecret)
             return true;
-        // Bearer token auth
+        // Bearer token auth (constant-time compare)
         if (config.authToken) {
-            const authHeader = req.headers.authorization;
-            if (authHeader === `Bearer ${config.authToken}`)
+            const authHeader = req.headers.authorization || '';
+            if (safeEqualString(authHeader, `Bearer ${config.authToken}`))
                 return true;
         }
         // HMAC signature auth (for GitHub-style webhooks)

package/dist/channels/whatsapp.d.ts

@@ -11,9 +11,7 @@ export declare class WhatsAppChannel implements Channel {
     private reconnectAttempts;
     private readonly maxReconnectAttempts;
     private readonly backoffDelays;
-    private sttProvider;
-    private ttsProvider;
-    private sttWarmedUp;
+    private voice;
     constructor(ctx: ChannelContext);
     start(): Promise<void>;
     stop(): void;

package/dist/channels/whatsapp.js

@@ -1,11 +1,11 @@
 import fs from 'node:fs';
 import { logger } from '../util/logger.js';
 import { saveMedia, isOversized } from '../media/store.js';
-import { retryWithBackoff } from '../util/retry.js';
-import { chunkText } from '../util/text.js';
+import { sendChunkedResponse } from './send-helpers.js';
 import { inboundLimiter } from '../util/rate-limiter.js';
 import { processInboundMessage } from './pipeline.js';
-import { initVoiceProviders } from '../voice/index.js';
+import { isChannelAdmin } from './admin.js';
+import { VoiceState } from './voice-state.js';
 const WHATSAPP_MAX_LENGTH = 8192;
 export class WhatsAppChannel {
     id = 'whatsapp';
@@ -19,18 +19,14 @@ export class WhatsAppChannel {
     reconnectAttempts = 0;
     maxReconnectAttempts = 10;
     backoffDelays = [1000, 5000, 15000, 30000, 60000];
-    sttProvider = null;
-    ttsProvider = null;
-    sttWarmedUp = false;
+    voice = new VoiceState('whatsapp');
     constructor(ctx) {
         this.ctx = ctx;
         this.allowedNumbers = new Set(ctx.config.whatsapp?.allowedNumbers ?? []);
     }
     async start() {
-        // Initialize voice providers
-        const { stt, tts } = initVoiceProviders(this.ctx.config.voice);
-        this.sttProvider = stt;
-        this.ttsProvider = tts;
+        // Initialize voice providers (STT + TTS)
+        this.voice.init(this.ctx.config);
         try {
             const { default: makeWASocket, useMultiFileAuthState, DisconnectReason, downloadMediaMessage, fetchLatestBaileysVersion } = await import('@whiskeysockets/baileys');
             const sessionPath = this.ctx.config.whatsapp?.sessionPath ?? `${process.env.HOME}/.beecork/whatsapp-session`;
@@ -101,56 +97,63 @@ export class WhatsAppChannel {
                     msg.message.extendedTextMessage?.text ||
                     msg.message.imageMessage?.caption ||
                     msg.message.videoMessage?.caption || '';
-                // Download media (in parallel)
-                const waDownloadTasks = [];
-                if (msg.message.imageMessage) {
-                    waDownloadTasks.push(downloadMediaMessage(msg, 'buffer', {})
-                        .then((buffer) => {
-                        if (buffer && !isOversized(buffer.length)) {
-                            const filePath = saveMedia(buffer, 'jpg');
-                            return { type: 'image', mimeType: msg.message.imageMessage.mimetype || 'image/jpeg', filePath };
-                        }
-                        return null;
-                    })
-                        .catch(() => null));
-                }
-                if (msg.message.audioMessage) {
-                    waDownloadTasks.push(downloadMediaMessage(msg, 'buffer', {})
-                        .then((buffer) => {
-                        if (buffer && !isOversized(buffer.length)) {
-                            const ext = msg.message.audioMessage.ptt ? 'ogg' : 'mp3';
-                            const filePath = saveMedia(buffer, ext);
+                const descriptors = [
+                    {
+                        key: 'imageMessage',
+                        build: (m, buf) => ({
+                            type: 'image',
+                            mimeType: m.imageMessage.mimetype || 'image/jpeg',
+                            filePath: saveMedia(buf, 'jpg'),
+                        }),
+                    },
+                    {
+                        key: 'audioMessage',
+                        build: (m, buf) => {
+                            const ext = m.audioMessage.ptt ? 'ogg' : 'mp3';
                             return {
-                                type: (msg.message.audioMessage.ptt ? 'voice' : 'audio'),
-                                mimeType: msg.message.audioMessage.mimetype || 'audio/ogg',
-                                filePath,
-                                duration: msg.message.audioMessage.seconds ?? undefined,
+                                type: m.audioMessage.ptt ? 'voice' : 'audio',
+                                mimeType: m.audioMessage.mimetype || 'audio/ogg',
+                                filePath: saveMedia(buf, ext),
+                                duration: m.audioMessage.seconds ?? undefined,
                             };
-                        }
-                        return null;
-                    })
-                        .catch(() => null));
-                }
-                if (msg.message.documentMessage) {
+                        },
+                    },
+                    {
+                        key: 'documentMessage',
+                        build: (m, buf) => {
+                            const ext = m.documentMessage.fileName?.split('.').pop() || 'bin';
+                            return {
+                                type: 'document',
+                                mimeType: m.documentMessage.mimetype || 'application/octet-stream',
+                                filePath: saveMedia(buf, ext, m.documentMessage.fileName ?? undefined),
+                                fileName: m.documentMessage.fileName ?? undefined,
+                            };
+                        },
+                    },
+                    {
+                        key: 'videoMessage',
+                        build: (m, buf) => ({
+                            type: 'video',
+                            mimeType: m.videoMessage.mimetype || 'video/mp4',
+                            filePath: saveMedia(buf, 'mp4'),
+                            duration: m.videoMessage.seconds ?? undefined,
+                        }),
+                    },
+                ];
+                const waDownloadTasks = [];
+                for (const d of descriptors) {
+                    if (!msg.message[d.key])
+                        continue;
                     waDownloadTasks.push(downloadMediaMessage(msg, 'buffer', {})
                         .then((buffer) => {
-                        if (buffer && !isOversized(buffer.length)) {
-                            const ext = msg.message.documentMessage.fileName?.split('.').pop() || 'bin';
-                            const filePath = saveMedia(buffer, ext, msg.message.documentMessage.fileName ?? undefined);
-                            return { type: 'document', mimeType: msg.message.documentMessage.mimetype || 'application/octet-stream', filePath, fileName: msg.message.documentMessage.fileName ?? undefined };
+                        if (!buffer || isOversized(buffer.length))
+                            return null;
+                        try {
+                            return d.build(msg.message, buffer);
                         }
-                        return null;
-                    })
-                        .catch(() => null));
-                }
-                if (msg.message.videoMessage) {
-                    waDownloadTasks.push(downloadMediaMessage(msg, 'buffer', {})
-                        .then((buffer) => {
-                        if (buffer && !isOversized(buffer.length)) {
-                            const filePath = saveMedia(buffer, 'mp4');
-                            return { type: 'video', mimeType: msg.message.videoMessage.mimetype || 'video/mp4', filePath, duration: msg.message.videoMessage.seconds ?? undefined };
+                        catch {
+                            return null;
                         }
-                        return null;
                     })
                         .catch(() => null));
                 }
@@ -159,10 +162,7 @@ export class WhatsAppChannel {
                     .filter((r) => r.status === 'fulfilled' && r.value !== null)
                     .map(r => r.value);
                 // Transcribe voice messages if STT is configured
-                if (this.sttProvider) {
-                    const { transcribeVoiceMessages } = await import('../voice/index.js');
-                    this.sttWarmedUp = await transcribeVoiceMessages(media, this.sttProvider, 'whatsapp', this.sttWarmedUp);
-                }
+                await this.voice.transcribe(media);
                 if (!text && media.length === 0)
                     return;
                 try {
@@ -173,7 +173,7 @@ export class WhatsAppChannel {
                         const cmdResult = await handleSharedCommand({
                             userId: waUserId,
                             text,
-                            isAdmin: this.allowedNumbers.size > 0 && waUserId === [...this.allowedNumbers][0],
+                            isAdmin: isChannelAdmin(this.allowedNumbers, waUserId, this.ctx.config.whatsapp?.adminNumber),
                             channelId: 'whatsapp',
                         }, this.ctx.tabManager);
                         if (cmdResult.handled) {
@@ -190,7 +190,7 @@ export class WhatsAppChannel {
                         channelId: 'whatsapp',
                         tabManager: this.ctx.tabManager,
                         voiceReplyMode: this.ctx.config.voice?.replyMode,
-                        ttsProvider: this.ttsProvider,
+                        ttsProvider: this.voice.tts,
                         userId: waUserId,
                         sendProgress: (msg) => {
                             sock.sendMessage(sender, { text: msg }).catch(() => { });
@@ -210,7 +210,8 @@ export class WhatsAppChannel {
                 }
                 catch (err) {
                     logger.error('WhatsApp message handler error:', err);
-                    await sock.sendMessage(sender, { text: 'Something went wrong processing your message. Check daemon logs for details.' }).catch(() => { });
+                    await sock.sendMessage(sender, { text: 'Something went wrong processing your message. Check daemon logs for details.' })
+                        .catch((sendErr) => logger.error('WhatsApp: failed to send fallback error message:', sendErr));
                 }
             });
         }
@@ -231,10 +232,12 @@ export class WhatsAppChannel {
         const sock = this.sock;
         if (!sock)
             return;
-        const chunks = chunkText(text, WHATSAPP_MAX_LENGTH);
-        for (const chunk of chunks) {
-            await retryWithBackoff(() => sock.sendMessage(peerId, { text: chunk }), [1000, 5000, 15000], 'whatsapp-send');
-        }
+        await sendChunkedResponse({
+            text,
+            maxLength: WHATSAPP_MAX_LENGTH,
+            retryLabel: 'whatsapp-send',
+            sendChunk: chunk => sock.sendMessage(peerId, { text: chunk }),
+        });
     }
     async sendNotification(message, _urgent) {
         const sock = this.sock;
@@ -261,16 +264,18 @@ export class WhatsAppChannel {
     }
     // ─── Private ───
     async sendResponse(jid, text, tabName) {
-        const prefix = tabName && tabName !== 'default' ? `[${tabName}] ` : '';
-        const chunks = chunkText(prefix + text, WHATSAPP_MAX_LENGTH);
         const sock = this.sock;
-        for (const chunk of chunks) {
-            try {
-                await retryWithBackoff(() => sock.sendMessage(jid, { text: chunk }), [1000, 5000, 15000], 'whatsapp-send');
-            }
-            catch (err) {
-                logger.error(`WhatsApp delivery failed for ${jid}:`, err);
-            }
+        try {
+            await sendChunkedResponse({
+                text,
+                tabName,
+                maxLength: WHATSAPP_MAX_LENGTH,
+                retryLabel: 'whatsapp-send',
+                sendChunk: chunk => sock.sendMessage(jid, { text: chunk }),
+            });
+        }
+        catch (err) {
+            logger.error(`WhatsApp delivery failed for ${jid}:`, err);
         }
     }
     isAllowed(jid) {

package/dist/cli/doctor.js

@@ -136,9 +136,12 @@ export async function runDoctor() {
     else {
         checks.push({ name: 'MCP config', status: 'pass', message: 'Default (beecork MCP only)' });
     }
-    // Print results
+    // Print results — gate ANSI on a real TTY so piping to a file/grep yields plain text.
     console.log('\nBeecork Doctor\n');
-    const icons = { pass: '\x1b[32m✓\x1b[0m', warn: '\x1b[33m!\x1b[0m', fail: '\x1b[31m✗\x1b[0m' };
+    const colored = process.stdout.isTTY && !process.env.NO_COLOR;
+    const icons = colored
+        ? { pass: '\x1b[32m✓\x1b[0m', warn: '\x1b[33m!\x1b[0m', fail: '\x1b[31m✗\x1b[0m' }
+        : { pass: '✓', warn: '!', fail: '✗' };
     for (const check of checks) {
         console.log(`  ${icons[check.status]} ${check.name}: ${check.message}`);
     }

package/dist/cli/handoff.js

@@ -1,18 +1,18 @@
 import { spawn } from 'node:child_process';
 import { getDb } from '../db/index.js';
 import { getConfig } from '../config.js';
+import { TabStore } from '../session/tab-store.js';
 export function exportTab(tabName) {
-    const db = getDb();
-    const tab = db.prepare('SELECT * FROM tabs WHERE name = ?').get(tabName);
+    const tab = TabStore.findByName(tabName);
     if (!tab)
         return null;
-    const messages = db.prepare('SELECT role, content FROM messages WHERE tab_id = ? ORDER BY created_at DESC LIMIT 5').all(tab.id);
+    const messages = getDb().prepare('SELECT role, content FROM messages WHERE tab_id = ? ORDER BY created_at DESC LIMIT 5').all(tab.id);
     return {
         name: tab.name,
-        sessionId: tab.session_id,
-        workingDir: tab.working_dir,
+        sessionId: tab.sessionId,
+        workingDir: tab.workingDir,
         status: tab.status,
-        lastActivity: tab.last_activity_at,
+        lastActivity: tab.lastActivityAt,
         recentMessages: messages.reverse(),
     };
 }

package/dist/config.d.ts

@@ -3,5 +3,9 @@ export declare function getConfig(): BeecorkConfig;
 export declare function saveConfig(config: BeecorkConfig): void;
 export declare function getTabConfig(tabName: string): TabConfig;
 export declare function resolveWorkingDir(tabName: string): string;
-export declare function getAdminUserId(): number;
 export declare function validateTabName(name: string): string | null;
+/**
+ * Like validateTabName but allows the literal name "default" (used by send/update
+ * endpoints that reference an existing tab rather than creating one).
+ */
+export declare function validateTabNameOrDefault(name: string): string | null;

package/dist/config.js

@@ -53,8 +53,8 @@ export function getConfig() {
 export function saveConfig(config) {
     const configPath = getConfigPath();
     fs.mkdirSync(path.dirname(configPath), { recursive: true });
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
-    fs.chmodSync(configPath, 0o600); // Owner-only read/write — contains API keys
+    // Owner-only mode set atomically with the write so there's no world-readable window.
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
     cachedConfig = config;
 }
 export function getTabConfig(tabName) {
@@ -65,10 +65,8 @@ export function resolveWorkingDir(tabName) {
     const tabConfig = getTabConfig(tabName);
     return expandHome(tabConfig.workingDir);
 }
-export function getAdminUserId() {
-    const config = getConfig();
-    return config.telegram.adminUserId ?? config.telegram.allowedUserIds[0];
-}
+// getAdminUserId removed — admin check now lives in channels/admin.ts (isChannelAdmin)
+// so all 3 channels share the same policy instead of each reimplementing.
 const TAB_NAME_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9-]{0,31}$/;
 export function validateTabName(name) {
     if (name === 'default')
@@ -79,8 +77,21 @@ export function validateTabName(name) {
         return 'Tab name must be alphanumeric + hyphens, max 32 chars';
     return null; // valid
 }
+/**
+ * Like validateTabName but allows the literal name "default" (used by send/update
+ * endpoints that reference an existing tab rather than creating one).
+ */
+export function validateTabNameOrDefault(name) {
+    if (name === 'default')
+        return null;
+    return validateTabName(name);
+}
 function mergeWithDefaults(raw) {
+    // Spread raw first so any future optional fields round-trip through saveConfig
+    // without needing to be enumerated here. Specific sections that need defaults
+    // get merged below.
     return {
+        ...raw,
         telegram: {
             ...DEFAULT_CONFIG.telegram,
             ...raw.telegram,
@@ -105,13 +116,5 @@ function mergeWithDefaults(raw) {
             ?? raw.pipe?.projectScanPaths
             ?? [...DEFAULT_PROJECT_SCAN_PATHS],
         deployment: raw.deployment ?? DEFAULT_CONFIG.deployment,
-        // Preserve optional config sections (no defaults needed)
-        whatsapp: raw.whatsapp,
-        discord: raw.discord,
-        webhook: raw.webhook,
-        voice: raw.voice,
-        groups: raw.groups,
-        notifications: raw.notifications,
-        mediaGenerators: raw.mediaGenerators,
     };
 }