beecork 1.4.11 → 1.6.0

package/dist/capabilities/index.d.ts

@@ -1,3 +1,3 @@
 export type { CapabilityPack, EnabledCapability } from './types.js';
 export { CAPABILITY_PACKS } from './packs.js';
-export { getAvailablePacks, getEnabledCapabilities, isEnabled, enablePack, disablePack, updateMcpConfig } from './manager.js';
+export { getAvailablePacks, getEnabledCapabilities, isEnabled, enablePack, disablePack, updateMcpConfig, } from './manager.js';

package/dist/capabilities/index.js

@@ -1,2 +1,2 @@
 export { CAPABILITY_PACKS } from './packs.js';
-export { getAvailablePacks, getEnabledCapabilities, isEnabled, enablePack, disablePack, updateMcpConfig } from './manager.js';
+export { getAvailablePacks, getEnabledCapabilities, isEnabled, enablePack, disablePack, updateMcpConfig, } from './manager.js';

package/dist/capabilities/manager.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
-import { execSync } from 'node:child_process';
+import { execFileSync } from 'node:child_process';
 import { getConfig, saveConfig } from '../config.js';
+const SAFE_NPM_PACKAGE = /^[@a-zA-Z0-9_/.-]+$/;
 import { getMcpConfigPath } from '../util/paths.js';
 import { logger } from '../util/logger.js';
 import { CAPABILITY_PACKS } from './packs.js';
@@ -15,28 +16,31 @@ export function getEnabledCapabilities() {
 }
 /** Check if a pack is enabled */
 export function isEnabled(packId) {
-    return getEnabledCapabilities().some(c => c.packId === packId);
+    return getEnabledCapabilities().some((c) => c.packId === packId);
 }
 /** Enable a capability pack */
 export function enablePack(packId, apiKey) {
-    const pack = CAPABILITY_PACKS.find(p => p.id === packId);
+    const pack = CAPABILITY_PACKS.find((p) => p.id === packId);
     if (!pack)
         throw new Error(`Unknown capability: ${packId}. Use 'beecork capabilities' to list.`);
     if (pack.requiresApiKey && !apiKey) {
         throw new Error(`${pack.name} requires an API key. Hint: ${pack.apiKeyHint}`);
     }
     // Install the MCP server package
+    if (!SAFE_NPM_PACKAGE.test(pack.mcpServer.package)) {
+        throw new Error(`Invalid package name in capability pack: ${pack.mcpServer.package}`);
+    }
     try {
         console.log(`Installing ${pack.mcpServer.package}...`);
-        execSync(`npm install -g ${pack.mcpServer.package}`, { stdio: 'pipe' });
+        execFileSync('npm', ['install', '-g', pack.mcpServer.package], { stdio: 'pipe' });
     }
-    catch (err) {
+    catch {
         logger.warn(`Package install skipped (may already be available via npx): ${pack.mcpServer.package}`);
     }
     // Update config
     const config = getConfig();
     const capabilities = config.capabilities || [];
-    const existing = capabilities.findIndex(c => c.packId === packId);
+    const existing = capabilities.findIndex((c) => c.packId === packId);
     const entry = { packId, apiKey, enabledAt: new Date().toISOString() };
     if (existing >= 0) {
         capabilities[existing] = entry;
@@ -54,7 +58,7 @@ export function enablePack(packId, apiKey) {
 export function disablePack(packId) {
     const config = getConfig();
     const capabilities = config.capabilities || [];
-    config.capabilities = capabilities.filter(c => c.packId !== packId);
+    config.capabilities = capabilities.filter((c) => c.packId !== packId);
     saveConfig(config);
     updateMcpConfig();
     logger.info(`Capability disabled: ${packId}`);
@@ -78,7 +82,7 @@ export function updateMcpConfig() {
     // Add enabled capability servers
     const capabilities = getEnabledCapabilities();
     for (const cap of capabilities) {
-        const pack = CAPABILITY_PACKS.find(p => p.id === cap.packId);
+        const pack = CAPABILITY_PACKS.find((p) => p.id === cap.packId);
         if (!pack)
             continue;
         // Resolve env vars
@@ -96,7 +100,7 @@ export function updateMcpConfig() {
             env[pack.apiKeyEnvVar] = cap.apiKey;
         }
         // Resolve args templates
-        const args = (pack.mcpServer.args || []).map(arg => arg.replace(/\$\{(\w+)\}/g, (_, varName) => {
+        const args = (pack.mcpServer.args || []).map((arg) => arg.replace(/\$\{(\w+)\}/g, (_, varName) => {
             if (varName === pack.apiKeyEnvVar)
                 return cap.apiKey || '';
             return process.env[varName] || '';

package/dist/capabilities/packs.js

@@ -9,7 +9,9 @@ export const CAPABILITY_PACKS = [
             package: '@notionhq/notion-mcp-server',
             command: 'npx',
             args: ['-y', '@notionhq/notion-mcp-server'],
-            env: { OPENAPI_MCP_HEADERS: '{"Authorization":"Bearer ${NOTION_API_KEY}","Notion-Version":"2022-06-28"}' },
+            env: {
+                OPENAPI_MCP_HEADERS: '{"Authorization":"Bearer ${NOTION_API_KEY}","Notion-Version":"2022-06-28"}',
+            },
         },
         requiresApiKey: true,
         apiKeyHint: 'Notion integration token (from notion.so/my-integrations)',

package/dist/channels/admin.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared admin check for channel commands. Single source of truth so the
+ * "who can run admin commands?" rule doesn't drift between channels.
+ *
+ * Policy:
+ *   - If an explicit admin peer ID is configured, only they are admin.
+ *   - Else the first allowed peer in the allowlist is admin.
+ *   - If the allowlist is empty, no one is admin (fail closed).
+ */
+export declare function isChannelAdmin(allowList: Iterable<string | number>, peerId: string | number | undefined, explicitAdmin?: string | number): boolean;

package/dist/channels/admin.js

@@ -0,0 +1,20 @@
+/**
+ * Shared admin check for channel commands. Single source of truth so the
+ * "who can run admin commands?" rule doesn't drift between channels.
+ *
+ * Policy:
+ *   - If an explicit admin peer ID is configured, only they are admin.
+ *   - Else the first allowed peer in the allowlist is admin.
+ *   - If the allowlist is empty, no one is admin (fail closed).
+ */
+export function isChannelAdmin(allowList, peerId, explicitAdmin) {
+    if (peerId === undefined || peerId === null)
+        return false;
+    if (explicitAdmin !== undefined && explicitAdmin !== null) {
+        return String(peerId) === String(explicitAdmin);
+    }
+    const first = [...allowList][0];
+    if (first === undefined)
+        return false;
+    return String(peerId) === String(first);
+}

package/dist/channels/command-handler.d.ts

@@ -9,19 +9,11 @@ export interface CommandResult {
     handled: boolean;
     response?: string;
 }
-export interface RouteResult {
-    effectiveTabName: string;
-    projectPath?: string;
-    confirmationMessage?: string;
-}
+export type { RouteResult } from '../projects/router.js';
 /**
  * Handle shared commands that work identically across all channels.
  * Returns { handled: true, response } if a command was matched.
  * The channel is responsible for sending the response via its own API.
  */
 export declare function handleSharedCommand(ctx: CommandContext, tabManager: TabManager): Promise<CommandResult>;
-/**
- * Shared project routing logic — resolves which tab/project to use for a message.
- * Extracted from the identical blocks in Telegram, WhatsApp, and Discord channels.
- */
-export declare function resolveProjectRoute(rawPrompt: string, tabName: string, text: string, userId: string): Promise<RouteResult>;
+export { resolveProjectRoute } from '../projects/router.js';

package/dist/channels/command-handler.js

@@ -4,6 +4,8 @@
  */
 import { timeAgo } from '../util/text.js';
 import { validateTabName } from '../config.js';
+import { exportTab, formatHandoffInfo } from '../session/handoff.js';
+import { logActivity } from '../timeline/index.js';
 /**
  * Handle shared commands that work identically across all channels.
  * Returns { handled: true, response } if a command was matched.
@@ -16,7 +18,9 @@ export async function handleSharedCommand(ctx, tabManager) {
         const tabs = tabManager.listTabs();
         if (tabs.length === 0)
             return { handled: true, response: 'No tabs.' };
-        const list = tabs.map(t => `• ${t.name} [${t.status}] — ${timeAgo(t.lastActivityAt)}`).join('\n');
+        const list = tabs
+            .map((t) => `• ${t.name} [${t.status}] — ${timeAgo(t.lastActivityAt)}`)
+            .join('\n');
         return { handled: true, response: list };
     }
     // /stop <name>
@@ -32,12 +36,22 @@ export async function handleSharedCommand(ctx, tabManager) {
         const rest = text.slice(5);
         const setPromptMatch = rest.match(/^(\S+)\s+--set-prompt\s+"([^"]+)"/);
         if (setPromptMatch) {
+            if (!isAdmin)
+                return { handled: true, response: 'Only admin can change system prompts.' };
             const tabName = setPromptMatch[1];
+            if (tabName !== 'default') {
+                const nameErr = validateTabName(tabName);
+                if (nameErr)
+                    return { handled: true, response: `Invalid tab name: ${nameErr}` };
+            }
             const systemPrompt = setPromptMatch[2];
-            const { getDb } = await import('../db/index.js');
-            const db = getDb();
-            db.prepare('UPDATE tabs SET system_prompt = ? WHERE name = ?').run(systemPrompt, tabName);
-            return { handled: true, response: `System prompt updated for tab "${tabName}"` };
+            const updated = tabManager.setSystemPrompt(tabName, systemPrompt);
+            return {
+                handled: true,
+                response: updated
+                    ? `System prompt updated for tab "${tabName}"`
+                    : `Tab "${tabName}" not found.`,
+            };
         }
         const spaceIdx = rest.indexOf(' ');
         if (spaceIdx === -1) {
@@ -51,42 +65,9 @@ export async function handleSharedCommand(ctx, tabManager) {
         // /tab with a valid name + message — not handled here, falls through to message handling
         return { handled: false };
     }
-    // /register [name]
-    if (text === '/register' || text.startsWith('/register ')) {
-        const { resolveUser, registerUser, hasAdmin } = await import('../users/index.js');
-        const existing = resolveUser(ctx.channelId, userId);
-        if (existing) {
-            return { handled: true, response: `You're already registered as "${existing.name}" (${existing.role}).` };
-        }
-        const name = text.slice(10).trim() || `user-${userId}`;
-        const role = hasAdmin() ? 'user' : 'admin';
-        const user = registerUser(name, ctx.channelId, userId, role);
-        return { handled: true, response: `Registered as "${user.name}" (${user.role}).${role === 'admin' ? ' You are the admin.' : ''}` };
-    }
-    // /link channel:peerId
-    if (text.startsWith('/link ')) {
-        const { resolveUser, linkIdentity } = await import('../users/index.js');
-        const user = resolveUser(ctx.channelId, userId);
-        if (!user)
-            return { handled: true, response: 'Register first: /register' };
-        const parts = text.slice(6).trim().split(':');
-        if (parts.length !== 2) {
-            return { handled: true, response: 'Usage: /link channel:peerId (e.g., /link discord:123456789)' };
-        }
-        const success = linkIdentity(user.id, parts[0], parts[1]);
-        return { handled: true, response: success ? `Linked ${parts[0]} identity.` : 'Failed to link — already linked or invalid.' };
-    }
-    // /users (admin only)
-    if (text === '/users') {
-        if (!isAdmin)
-            return { handled: true, response: 'Admin only.' };
-        const { listUsers } = await import('../users/index.js');
-        const users = listUsers();
-        if (users.length === 0)
-            return { handled: true, response: 'No registered users.' };
-        const list = users.map(u => `• ${u.name} [${u.role}] — ${u.id.slice(0, 8)}`).join('\n');
-        return { handled: true, response: `${users.length} user(s):\n${list}` };
-    }
+    // /register, /link, /users were part of unused multi-user scaffolding —
+    // removed in the audit fix pass. Beecork is single-user; admin is the first
+    // allowedUserId on Telegram (or config.telegram.adminUserId).
     // /watches
     if (text === '/watches' || text.startsWith('/watches@')) {
         const { getDb } = await import('../db/index.js');
@@ -94,23 +75,27 @@ export async function handleSharedCommand(ctx, tabManager) {
         const watchers = db.prepare('SELECT * FROM watchers ORDER BY created_at').all();
         if (watchers.length === 0)
             return { handled: true, response: 'No watchers configured.' };
-        const watchList = watchers.map((w) => {
+        const watchList = watchers
+            .map((w) => {
             const status = w.enabled ? 'active' : 'disabled';
             return `[${status}] ${w.name} -- ${w.schedule} (triggers: ${w.trigger_count})`;
-        }).join('\n');
+        })
+            .join('\n');
         return { handled: true, response: `Watchers:\n${watchList}` };
     }
     // /tasks
     if (text === '/tasks' || text.startsWith('/tasks@')) {
         const { getDb } = await import('../db/index.js');
         const db = getDb();
-        const tasks = db.prepare('SELECT * FROM tasks WHERE user_id = ? ORDER BY created_at').all('local');
+        const tasks = db.prepare('SELECT * FROM tasks ORDER BY created_at').all();
         if (tasks.length === 0)
             return { handled: true, response: 'No tasks scheduled.' };
-        const taskList = tasks.map((t) => {
+        const taskList = tasks
+            .map((t) => {
             const status = t.enabled ? 'enabled' : 'disabled';
             return `[${status}] ${t.name} (${t.schedule_type}: ${t.schedule}) -> tab:${t.tab_name}`;
-        }).join('\n');
+        })
+            .join('\n');
         return { handled: true, response: `Tasks:\n${taskList}` };
     }
     // /cost
@@ -127,14 +112,17 @@ export async function handleSharedCommand(ctx, tabManager) {
     // /handoff [tab]
     if (text.startsWith('/handoff')) {
         const tabName = text.slice(9).trim() || 'default';
-        const { exportTab, formatHandoffInfo } = await import('../cli/handoff.js');
         const info = exportTab(tabName);
         if (!info)
             return { handled: true, response: `Tab "${tabName}" not found.` };
+        logActivity('user_command', '/handoff', { tabName });
         return { handled: true, response: formatHandoffInfo(info) };
     }
     // /folders (also accept legacy /projects)
-    if (text === '/folders' || text === '/projects' || text.startsWith('/folders@') || text.startsWith('/projects@')) {
+    if (text === '/folders' ||
+        text === '/projects' ||
+        text.startsWith('/folders@') ||
+        text.startsWith('/projects@')) {
         const { listProjects } = await import('../projects/index.js');
         const projects = listProjects();
         if (projects.length === 0)
@@ -151,15 +139,22 @@ export async function handleSharedCommand(ctx, tabManager) {
         return { handled: true, response: msg };
     }
     // /folder <name> (also accept legacy /project <name>)
-    if ((text.startsWith('/folder ') && !text.startsWith('/folders')) || (text.startsWith('/project ') && !text.startsWith('/projects'))) {
+    if ((text.startsWith('/folder ') && !text.startsWith('/folders')) ||
+        (text.startsWith('/project ') && !text.startsWith('/projects'))) {
         const prefix = text.startsWith('/folder ') ? '/folder ' : '/project ';
         const name = text.slice(prefix.length).trim();
         const { getProject, setUserContext } = await import('../projects/index.js');
         const project = getProject(name);
         if (!project)
-            return { handled: true, response: `Folder "${name}" not found. Use /folders to list or /newfolder to create.` };
+            return {
+                handled: true,
+                response: `Folder "${name}" not found. Use /folders to list or /newfolder to create.`,
+            };
         setUserContext(userId, project.name, project.name);
-        return { handled: true, response: `Switched to folder: ${project.name}\nPath: ${project.path}\n\nNext messages will work in this folder.` };
+        return {
+            handled: true,
+            response: `Switched to folder: ${project.name}\nPath: ${project.path}\n\nNext messages will work in this folder.`,
+        };
     }
     // /newfolder <name> [path] (also accept legacy /newproject)
     if (text.startsWith('/newfolder ') || text.startsWith('/newproject ')) {
@@ -172,18 +167,23 @@ export async function handleSharedCommand(ctx, tabManager) {
         const { createProject, setUserContext } = await import('../projects/index.js');
         const project = createProject(name, customPath);
         setUserContext(userId, project.name, project.name);
-        return { handled: true, response: `✓ Folder "${name}" created at ${project.path}\nSwitched to this folder.` };
+        return {
+            handled: true,
+            response: `✓ Folder "${name}" created at ${project.path}\nSwitched to this folder.`,
+        };
     }
     // /close <tab>
     if (text.startsWith('/close ')) {
         const tabNameToClose = text.slice(7).trim();
         if (!tabNameToClose)
             return { handled: true, response: 'Usage: /close <tabname>' };
-        // Stop any running subprocess before deleting records
-        tabManager.stopTab(tabNameToClose);
-        const { closeTab } = await import('../projects/index.js');
-        const closed = closeTab(tabNameToClose);
-        return { handled: true, response: closed ? `Tab "${tabNameToClose}" permanently closed. History deleted.` : `Tab "${tabNameToClose}" not found.` };
+        const closed = tabManager.closeTab(tabNameToClose);
+        return {
+            handled: true,
+            response: closed
+                ? `Tab "${tabNameToClose}" permanently closed. History deleted.`
+                : `Tab "${tabNameToClose}" not found.`,
+        };
     }
     // /fresh <folder>
     if (text.startsWith('/fresh ')) {
@@ -194,36 +194,42 @@ export async function handleSharedCommand(ctx, tabManager) {
             return { handled: true, response: `Folder "${folderName}" not found.` };
         const freshTabName = `${folderName}-${Date.now().toString(36).slice(-4)}`;
         setUserContext(userId, project.name, freshTabName);
-        return { handled: true, response: `Fresh start in "${folderName}" (tab: ${freshTabName})\nSend your message now.` };
-    }
-    return { handled: false };
-}
-/**
- * Shared project routing logic — resolves which tab/project to use for a message.
- * Extracted from the identical blocks in Telegram, WhatsApp, and Discord channels.
- */
-export async function resolveProjectRoute(rawPrompt, tabName, text, userId) {
-    if (tabName !== 'default' || text.startsWith('/tab ')) {
-        return { effectiveTabName: tabName };
+        return {
+            handled: true,
+            response: `Fresh start in "${folderName}" (tab: ${freshTabName})\nSend your message now.`,
+        };
     }
-    try {
-        const { routeMessage, setUserContext, listProjects } = await import('../projects/index.js');
-        const decision = routeMessage(rawPrompt, { userId });
-        if (decision.needsConfirmation) {
-            const projects = listProjects().filter((p) => p.type === 'user-project');
-            const options = projects.map((p, i) => `${i + 1}) ${p.name}`).join('\n');
+    // /history [date|yesterday]
+    if (text === '/history' || text.startsWith('/history ')) {
+        const dateArg = text.slice(9).trim();
+        const { getTimeline, formatTimeline } = await import('../timeline/index.js');
+        let date;
+        if (dateArg === 'yesterday') {
+            date = new Date(Date.now() - 86400000).toISOString().slice(0, 10);
+        }
+        else if (dateArg) {
+            date = dateArg;
+        }
+        else {
+            date = new Date().toISOString().slice(0, 10);
+        }
+        const events = getTimeline({ date, limit: 30 });
+        return { handled: true, response: formatTimeline(events) };
+    }
+    // /knowledge
+    if (text === '/knowledge') {
+        const { getAllKnowledge, formatKnowledgeForContext } = await import('../knowledge/index.js');
+        const entries = getAllKnowledge();
+        if (entries.length === 0) {
             return {
-                effectiveTabName: tabName,
-                confirmationMessage: `Which project?\n${options}\n\nReply with the number, or just send your message with /project <name> first.`,
+                handled: true,
+                response: 'No knowledge stored yet. Beecork learns from your conversations.',
             };
         }
-        setUserContext(userId, decision.project.name, decision.tabName);
-        return {
-            effectiveTabName: decision.tabName,
-            projectPath: decision.project.path,
-        };
-    }
-    catch {
-        return { effectiveTabName: tabName };
+        return { handled: true, response: formatKnowledgeForContext(entries).slice(0, 4000) };
     }
+    return { handled: false };
 }
+// resolveProjectRoute lives at src/projects/router.ts — re-exported here so
+// existing callers (channels/pipeline.ts) don't need to update their import path.
+export { resolveProjectRoute } from '../projects/router.js';

package/dist/channels/discord.d.ts

@@ -1,22 +1,17 @@
-import type { Channel, ChannelContext, InboundMessageHandler, SendOptions } from './types.js';
+import type { Channel, ChannelContext, SendOptions } from './types.js';
 export declare class DiscordChannel implements Channel {
     readonly id = "discord";
     readonly name = "Discord";
     readonly maxMessageLength = 2000;
-    readonly supportsStreaming = false;
-    readonly supportsMedia = true;
     private client;
     private ctx;
     private allowedUserIds;
-    private sttProvider;
-    private ttsProvider;
-    private sttWarmedUp;
+    private voice;
     constructor(ctx: ChannelContext);
     start(): Promise<void>;
     stop(): void;
-    onMessage(_handler: InboundMessageHandler): void;
-    sendMessage(peerId: string, text: string, options?: SendOptions): Promise<void>;
-    sendNotification(message: string, urgent?: boolean): Promise<void>;
+    sendMessage(peerId: string, text: string, _options?: SendOptions): Promise<void>;
+    sendNotification(message: string, _urgent?: boolean): Promise<void>;
     setTyping(peerId: string, active: boolean): Promise<void>;
     private sendResponse;
 }

package/dist/channels/discord.js

@@ -1,22 +1,30 @@
+/*
+ * Discord integration via discord.js (peer-optional, dynamic-imported).
+ *
+ * discord.js's strict union types (PartialGroupDMChannel, TextChannel, etc.)
+ * require narrowing at every send/sendTyping callsite. The runtime channel
+ * objects we receive in handlers all support these methods, but expressing
+ * that to TypeScript via the published types is a significant refactor with
+ * no runtime benefit. We accept `any` at this library boundary — same pattern
+ * as the WhatsApp/baileys integration.
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { logger } from '../util/logger.js';
-import { chunkText, parseTabMessage } from '../util/text.js';
-import { retryWithBackoff } from '../util/retry.js';
+import { parseTabMessage } from '../util/text.js';
+import { sendChunkedResponse } from './send-helpers.js';
 import { inboundLimiter } from '../util/rate-limiter.js';
 import { saveMedia, isOversized } from '../media/store.js';
-import { initVoiceProviders } from '../voice/index.js';
+import { VoiceState } from './voice-state.js';
 import { processInboundMessage } from './pipeline.js';
+import { isChannelAdmin } from './admin.js';
 export class DiscordChannel {
     id = 'discord';
     name = 'Discord';
     maxMessageLength = 2000;
-    supportsStreaming = false; // Discord message editing is rate-limited
-    supportsMedia = true;
     client = null; // Discord.js Client
     ctx;
     allowedUserIds;
-    sttProvider = null;
-    ttsProvider = null;
-    sttWarmedUp = false;
+    voice = new VoiceState('discord');
     constructor(ctx) {
         this.ctx = ctx;
         this.allowedUserIds = new Set((ctx.config.discord?.allowedUserIds ?? []).map(String));
@@ -37,10 +45,8 @@ export class DiscordChannel {
                 GatewayIntentBits.MessageContent,
             ],
         });
-        // Voice providers
-        const { stt, tts } = initVoiceProviders(this.ctx.config.voice);
-        this.sttProvider = stt;
-        this.ttsProvider = tts;
+        // Voice providers (STT + TTS)
+        this.voice.init(this.ctx.config);
         this.client.on(Events.MessageCreate, async (message) => {
             // Ignore bot messages
             if (message.author.bot)
@@ -59,17 +65,18 @@ export class DiscordChannel {
             }
             // Rate limit
             if (!inboundLimiter.check(this.id)) {
-                await message.reply("I'm receiving too many messages right now. Please wait a moment.").catch(() => { });
+                await message
+                    .reply("I'm receiving too many messages right now. Please wait a moment.")
+                    .catch(() => { });
                 return;
             }
             const text = message.content
                 .replace(/<@!?\d+>/g, '') // Remove mentions
                 .trim();
-            // Warm up STT connection on first message with attachments
-            if (this.sttProvider && !this.sttWarmedUp && message.attachments.size > 0) {
-                this.sttProvider.warmup?.();
-                this.sttWarmedUp = true;
-            }
+            // Warm up STT connection on first message with attachments.
+            // (Discord intentionally only warms up; it doesn't transcribe like Telegram/WhatsApp.)
+            if (message.attachments.size > 0)
+                await this.voice.warmup();
             // Download attachments
             const media = [];
             for (const attachment of message.attachments.values()) {
@@ -115,7 +122,7 @@ export class DiscordChannel {
                     const cmdResult = await handleSharedCommand({
                         userId: message.author.id,
                         text,
-                        isAdmin: this.allowedUserIds.size > 0 && message.author.id === [...this.allowedUserIds][0],
+                        isAdmin: isChannelAdmin(this.allowedUserIds, message.author.id, this.ctx.config.discord?.adminUserId),
                         channelId: 'discord',
                     }, this.ctx.tabManager);
                     if (cmdResult.handled) {
@@ -127,12 +134,16 @@ export class DiscordChannel {
                 // Discord-specific: use thread name as tab if in a thread
                 let overrideTabName;
                 if (message.channel.isThread?.()) {
-                    const threadName = (message.channel.name || '')
+                    const sanitized = (message.channel.name || '')
                         .replace(/[^a-zA-Z0-9-]/g, '-')
                         .replace(/^-+|-+$/g, '')
                         .slice(0, 32);
-                    if (threadName && tabName === 'default')
-                        overrideTabName = threadName;
+                    // Run the synthesized name through validateTabName so weird thread
+                    // names (empty, starts with hyphen, "default") don't blow up downstream.
+                    const { validateTabName } = await import('../config.js');
+                    if (sanitized && tabName === 'default' && !validateTabName(sanitized)) {
+                        overrideTabName = sanitized;
+                    }
                 }
                 // Typing indicator refresh
                 const typingInterval = setInterval(() => {
@@ -146,7 +157,7 @@ export class DiscordChannel {
                         channelId: 'discord',
                         tabManager: this.ctx.tabManager,
                         voiceReplyMode: this.ctx.config.voice?.replyMode,
-                        ttsProvider: this.ttsProvider,
+                        ttsProvider: this.voice.tts,
                         userId: message.author.id,
                         sendProgress: (msg) => {
                             message.channel.send(msg).catch(() => { });
@@ -188,26 +199,25 @@ export class DiscordChannel {
         }
         logger.info('Discord bot stopped');
     }
-    onMessage(_handler) {
-        // Messages are handled directly in start()
-    }
-    async sendMessage(peerId, text, options) {
+    async sendMessage(peerId, text, _options) {
         if (!this.client)
             return;
         try {
             const channel = await this.client.channels.fetch(peerId);
             if (!channel?.isTextBased())
                 return;
-            const chunks = chunkText(text, this.maxMessageLength);
-            for (const chunk of chunks) {
-                await retryWithBackoff(() => channel.send(chunk), [1000, 5000, 15000], 'discord-send');
-            }
+            await sendChunkedResponse({
+                text,
+                maxLength: this.maxMessageLength,
+                retryLabel: 'discord-send',
+                sendChunk: (chunk) => channel.send(chunk),
+            });
         }
         catch (err) {
             logger.error(`Discord send failed for ${peerId}:`, err);
         }
     }
-    async sendNotification(message, urgent) {
+    async sendNotification(message, _urgent) {
         if (!this.client)
             return;
         // Send to all allowed users via DM
@@ -235,15 +245,22 @@ export class DiscordChannel {
         catch { }
     }
     async sendResponse(message, text, tabName) {
-        const prefix = tabName && tabName !== 'default' ? `[${tabName}] ` : '';
-        const fullText = prefix + text;
-        const chunks = chunkText(fullText, this.maxMessageLength);
-        // First chunk as reply, rest as follow-ups
-        if (chunks.length > 0) {
-            await retryWithBackoff(() => message.reply(chunks[0]), [1000, 5000], 'discord-reply');
-        }
-        for (let i = 1; i < chunks.length; i++) {
-            await retryWithBackoff(() => message.channel.send(chunks[i]), [1000, 5000], 'discord-send');
-        }
+        // Discord quirk: first chunk uses message.reply so it threads under the
+        // original user message; follow-ups use channel.send. sendChunkedResponse
+        // handles prefix + chunking + retry envelope; the closure-tracked chunkIdx
+        // keeps the "first chunk replies, rest send" behavior.
+        let chunkIdx = 0;
+        await sendChunkedResponse({
+            text,
+            tabName,
+            maxLength: this.maxMessageLength,
+            retryDelays: [1000, 5000],
+            retryLabel: 'discord-send',
+            sendChunk: (chunk) => {
+                const isFirst = chunkIdx === 0;
+                chunkIdx++;
+                return isFirst ? message.reply(chunk) : message.channel.send(chunk);
+            },
+        });
     }
 }

package/dist/channels/index.d.ts

@@ -4,4 +4,4 @@ export { WhatsAppChannel } from './whatsapp.js';
 export { WebhookChannel } from './webhook.js';
 export { DiscordChannel } from './discord.js';
 export { loadCommunityChannels } from './loader.js';
-export type { Channel, ChannelContext, InboundMessage, InboundMessageHandler, MediaAttachment, SendOptions } from './types.js';
+export type { Channel, ChannelContext, MediaAttachment, SendOptions } from './types.js';