beecork 1.4.11 → 1.5.0

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

@@ -32,12 +32,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 +61,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');
@@ -104,7 +81,7 @@ export async function handleSharedCommand(ctx, tabManager) {
     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) => {
@@ -179,10 +156,7 @@ export async function handleSharedCommand(ctx, tabManager) {
         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);
+        const closed = tabManager.closeTab(tabNameToClose);
         return { handled: true, response: closed ? `Tab "${tabNameToClose}" permanently closed. History deleted.` : `Tab "${tabNameToClose}" not found.` };
     }
     // /fresh <folder>
@@ -196,34 +170,34 @@ export async function handleSharedCommand(ctx, tabManager) {
         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 };
-    }
-    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');
-            return {
-                effectiveTabName: tabName,
-                confirmationMessage: `Which project?\n${options}\n\nReply with the number, or just send your message with /project <name> first.`,
-            };
+    // /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);
         }
-        setUserContext(userId, decision.project.name, decision.tabName);
-        return {
-            effectiveTabName: decision.tabName,
-            projectPath: decision.project.path,
-        };
-    }
-    catch {
-        return { effectiveTabName: tabName };
+        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 { handled: true, response: 'No knowledge stored yet. Beecork learns from your conversations.' };
+        }
+        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

@@ -8,9 +8,7 @@ export declare class DiscordChannel implements Channel {
     private client;
     private ctx;
     private allowedUserIds;
-    private sttProvider;
-    private ttsProvider;
-    private sttWarmedUp;
+    private voice;
     constructor(ctx: ChannelContext);
     start(): Promise<void>;
     stop(): void;

package/dist/channels/discord.js

@@ -1,10 +1,11 @@
 import { logger } from '../util/logger.js';
-import { chunkText, parseTabMessage } from '../util/text.js';
+import { chunkText, formatTabbedResponse, parseTabMessage } from '../util/text.js';
 import { retryWithBackoff } from '../util/retry.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';
@@ -14,9 +15,7 @@ export class DiscordChannel {
     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 +36,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)
@@ -65,11 +62,10 @@ export class DiscordChannel {
             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 +111,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 +123,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 +146,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(() => { });
@@ -235,15 +235,15 @@ 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. The shared helper
+        // takes a sendChunk callback so each channel keeps its platform-specific
+        // dispatch while sharing chunk + prefix + retry logic.
+        const full = formatTabbedResponse(text, tabName);
+        const chunks = chunkText(full, this.maxMessageLength);
+        for (let i = 0; i < chunks.length; i++) {
+            const isFirst = i === 0;
+            await retryWithBackoff(() => isFirst ? message.reply(chunks[i]) : message.channel.send(chunks[i]), [1000, 5000], isFirst ? 'discord-reply' : 'discord-send');
         }
     }
 }

package/dist/channels/loader.js

@@ -37,7 +37,6 @@ export async function loadCommunityChannels(ctx) {
                     continue;
                 if (!allowlist.includes(dir))
                     continue;
-                const channelName = dir.slice(CHANNEL_PREFIX.length);
                 const pkgPath = path.join(searchPath, dir);
                 try {
                     // Read package.json to find the main entry

package/dist/channels/send-helpers.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Send a tab-prefixed, chunked, retried response through any channel.
+ *
+ * Each channel just provides:
+ *   - sendChunk(text): the platform-specific send call for one chunk
+ *   - maxLength:       the platform's per-message limit
+ *   - retryLabel:      label for logger (e.g. "telegram-send")
+ *
+ * Replaces near-identical per-channel implementations that had already
+ * drifted in subtle ways (different prefix gates, different retry envelopes).
+ */
+export declare function sendChunkedResponse(opts: {
+    text: string;
+    tabName?: string;
+    maxLength: number;
+    retryLabel: string;
+    retryDelays?: number[];
+    sendChunk: (chunk: string) => Promise<unknown>;
+}): Promise<void>;

package/dist/channels/send-helpers.js

@@ -0,0 +1,21 @@
+import { chunkText, formatTabbedResponse } from '../util/text.js';
+import { retryWithBackoff } from '../util/retry.js';
+/**
+ * Send a tab-prefixed, chunked, retried response through any channel.
+ *
+ * Each channel just provides:
+ *   - sendChunk(text): the platform-specific send call for one chunk
+ *   - maxLength:       the platform's per-message limit
+ *   - retryLabel:      label for logger (e.g. "telegram-send")
+ *
+ * Replaces near-identical per-channel implementations that had already
+ * drifted in subtle ways (different prefix gates, different retry envelopes).
+ */
+export async function sendChunkedResponse(opts) {
+    const full = formatTabbedResponse(opts.text, opts.tabName);
+    const chunks = chunkText(full, opts.maxLength);
+    const delays = opts.retryDelays ?? [1000, 5000, 15000];
+    for (const chunk of chunks) {
+        await retryWithBackoff(() => opts.sendChunk(chunk), delays, opts.retryLabel);
+    }
+}

package/dist/channels/telegram.d.ts

@@ -1,10 +1,4 @@
 import type { Channel, ChannelContext, InboundMessageHandler, SendOptions } from './types.js';
-/** Format tab status for Telegram display */
-export declare function formatTabStatus(tabs: Array<{
-    name: string;
-    status: string;
-    lastActivityAt: string;
-}>): string;
 export declare class TelegramChannel implements Channel {
     readonly id = "telegram";
     readonly name = "Telegram";
@@ -14,13 +8,11 @@ export declare class TelegramChannel implements Channel {
     private bot;
     private ctx;
     private activeChatIds;
-    private sttProvider;
-    private ttsProvider;
+    private voice;
     private botUserId;
     private botUsername;
     private mutedGroups;
     private welcomeSent;
-    private sttWarmedUp;
     constructor(ctx: ChannelContext);
     start(): Promise<void>;
     stop(): void;

package/dist/channels/telegram.js

@@ -1,24 +1,23 @@
 import TelegramBot from 'node-telegram-bot-api';
 import fs from 'node:fs';
 import path from 'node:path';
-import { chunkText, timeAgo, parseTabMessage } from '../util/text.js';
+import { chunkText, parseTabMessage, formatTabbedResponse } from '../util/text.js';
 import { logger } from '../util/logger.js';
 import { retryWithBackoff } from '../util/retry.js';
-import { getAdminUserId } from '../config.js';
 import { getLogsDir } from '../util/paths.js';
 import { saveMedia, isOversized } from '../media/store.js';
 import { inboundLimiter, groupLimiter } 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 DEFAULT_GROUP_CONFIG = { activationMode: 'mention', maxResponsesPerMinute: 3, tabPerGroup: true };
-/** Format tab status for Telegram display */
-export function formatTabStatus(tabs) {
-    if (tabs.length === 0)
-        return 'No tabs.';
-    return tabs.map(t => {
-        const ago = timeAgo(t.lastActivityAt);
-        return `• ${t.name} [${t.status}] — ${ago}`;
-    }).join('\n');
+/**
+ * Strip Telegram bot tokens out of strings before logging. Telegram embeds
+ * the token in the URL path (e.g. https://api.telegram.org/bot1234:abc.../method),
+ * so on fetch errors the message/cause can leak the token to disk.
+ */
+function sanitizeBotToken(text) {
+    return text.replace(/bot\d+:[A-Za-z0-9_-]+/g, 'bot<REDACTED>');
 }
 export class TelegramChannel {
     id = 'telegram';
@@ -29,13 +28,11 @@ export class TelegramChannel {
     bot;
     ctx;
     activeChatIds = new Set();
-    sttProvider = null;
-    ttsProvider = null;
+    voice = new VoiceState('telegram');
     botUserId = null;
     botUsername = null;
     mutedGroups = new Set();
     welcomeSent = new Set();
-    sttWarmedUp = false;
     constructor(ctx) {
         this.ctx = ctx;
         this.bot = new TelegramBot(ctx.config.telegram.token, {
@@ -57,10 +54,8 @@ export class TelegramChannel {
         catch (err) {
             logger.error('Failed to clear pending updates, starting anyway:', err);
         }
-        // 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);
         this.bot.startPolling();
         // Cache bot identity for group mention detection
         try {
@@ -101,7 +96,17 @@ export class TelegramChannel {
                 await this.bot.sendMessage(userId, message);
                 this.activeChatIds.add(userId);
             }
-            catch { /* User hasn't started conversation yet */ }
+            catch (err) {
+                // Differentiate: 400 "chat not found" means the user has not started a
+                // conversation with the bot yet — silently skip. Anything else (rate
+                // limit, bot blocked, network) is a real delivery failure worth logging.
+                const errAny = err;
+                const status = errAny?.response?.statusCode;
+                const isChatNotFound = status === 400 || /chat not found/i.test(errAny?.message || '');
+                if (!isChatNotFound) {
+                    logger.warn(`Telegram notify to ${userId} failed (status=${status ?? '?'}):`, sanitizeBotToken(errAny?.message || String(err)));
+                }
+            }
         }
     }
     async setTyping(peerId, active) {
@@ -138,9 +143,9 @@ export class TelegramChannel {
                         'Send any message and I\'ll pass it to Claude Code.',
                         '',
                         'Quick tips:',
-                        '\u2022 `/tab name message` \u2014 organize work into tabs',
-                        '\u2022 `/tabs` \u2014 see what\'s running',
-                        '\u2022 `/stop name` \u2014 stop a tab',
+                        '\u2022 /tab name message \u2014 organize work into tabs',
+                        '\u2022 /tabs \u2014 see what\'s running',
+                        '\u2022 /stop name \u2014 stop a tab',
                         '',
                         'Let\'s get started! Send me something.',
                     ].join('\n'));
@@ -230,10 +235,7 @@ export class TelegramChannel {
                 .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, 'telegram', this.sttWarmedUp);
-            }
+            await this.voice.transcribe(media);
             // Skip if no text AND no media
             if (!text && media.length === 0)
                 return;
@@ -255,7 +257,10 @@ export class TelegramChannel {
             }
             catch (err) {
                 logger.error('Telegram: error handling message:', err);
-                await this.bot.sendMessage(chatId, 'Something went wrong processing your message. Check daemon logs for details.');
+                // Wrap the fallback send so a Telegram outage doesn't escalate to an
+                // unhandledRejection on the message-event handler.
+                this.bot.sendMessage(chatId, 'Something went wrong processing your message. Check daemon logs for details.')
+                    .catch(sendErr => logger.error('Telegram: failed to send fallback error message:', sendErr));
             }
         });
     }
@@ -271,35 +276,8 @@ export class TelegramChannel {
             await this.bot.sendMessage(chatId, 'Beecork unmuted in this group.');
             return;
         }
-        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 });
-            await this.sendResponse(chatId, formatTimeline(events));
-            return;
-        }
-        if (text === '/knowledge') {
-            const { getAllKnowledge, formatKnowledgeForContext } = await import('../knowledge/index.js');
-            const entries = getAllKnowledge();
-            if (entries.length === 0) {
-                await this.bot.sendMessage(chatId, 'No knowledge stored yet. Beecork learns from your conversations.');
-                return;
-            }
-            const formatted = formatKnowledgeForContext(entries);
-            await this.sendResponse(chatId, formatted.slice(0, 4000));
-            return;
-        }
-        // Shared command handler (covers /tabs, /stop, /tab, /projects, /project, /newproject, /close, /fresh, /register, /link, /users, /cost, /activity, /handoff)
+        // /history and /knowledge now handled by the shared command handler.
+        // Shared command handler (covers /tabs, /stop, /tab, /projects, /project, /newproject, /close, /fresh, /cost, /activity, /handoff, /history, /knowledge)
         const { handleSharedCommand } = await import('./command-handler.js');
         const result = await handleSharedCommand({
             userId: String(userId || 'default'),
@@ -381,7 +359,7 @@ export class TelegramChannel {
                 channelId: 'telegram',
                 tabManager: this.ctx.tabManager,
                 voiceReplyMode: this.ctx.config.voice?.replyMode,
-                ttsProvider: this.ttsProvider,
+                ttsProvider: this.voice.tts,
                 userId: String(chatId),
                 sendProgress: (msg) => {
                     this.bot.sendMessage(chatId, msg).catch(() => { });
@@ -457,9 +435,9 @@ export class TelegramChannel {
         }
     }
     async sendResponse(chatId, text, tabName) {
-        const prefix = tabName && tabName !== 'default' ? `[${tabName}] ` : '';
-        const fullText = prefix + text;
+        const fullText = formatTabbedResponse(text, tabName);
         const chunks = chunkText(fullText);
+        // Telegram-specific: if the response would be >10 chunks, send a preview + the rest as a file.
         if (chunks.length > 10) {
             for (let i = 0; i < 3; i++) {
                 await this.sendWithRetry(chatId, chunks[i]);
@@ -476,18 +454,16 @@ export class TelegramChannel {
     }
     async sendWithRetry(chatId, text) {
         try {
-            await retryWithBackoff(async () => {
-                try {
-                    await this.bot.sendMessage(chatId, text, { parse_mode: 'Markdown' });
-                }
-                catch {
-                    await this.bot.sendMessage(chatId, text);
-                }
-            }, [1000, 5000, 15000], 'telegram-send');
+            await retryWithBackoff(
+            // Send as plain text — Telegram's legacy "Markdown" parser silently mangles
+            // underscores/asterisks in Claude's responses (code identifiers, names),
+            // and Beecork has no escaping pass for it.
+            () => this.bot.sendMessage(chatId, text), [1000, 5000, 15000], 'telegram-send');
         }
         catch (err) {
             const failLog = path.join(getLogsDir(), 'delivery-failures.log');
-            const entry = `[${new Date().toISOString()}] chatId=${chatId} error=${err instanceof Error ? err.message : err} text=${text.slice(0, 200)}\n`;
+            const sanitizedErr = sanitizeBotToken(err instanceof Error ? err.message : String(err));
+            const entry = `[${new Date().toISOString()}] chatId=${chatId} error=${sanitizedErr} text=${text.slice(0, 200)}\n`;
             fs.appendFileSync(failLog, entry);
             logger.error(`Delivery failed after retries for chat ${chatId}`);
         }
@@ -514,9 +490,8 @@ export class TelegramChannel {
         return this.ctx.config.telegram.allowedUserIds.includes(userId);
     }
     isAdmin(userId) {
-        if (!userId)
-            return false;
-        return userId === getAdminUserId();
+        const cfg = this.ctx.config.telegram;
+        return isChannelAdmin(cfg.allowedUserIds, userId, cfg.adminUserId);
     }
     async setReaction(chatId, messageId, emoji) {
         try {