const length = (text || '').length;

// ~25ms per character, clamped between 0.4s and 4s

// Short "hey ❤️" (~6 chars) → 0.4s | Medium reply (~120 chars) → 3s | Long reply → 4s cap

const delay = Math.min(4000, Math.max(400, length * 25));

// Add a small random jitter (±15%) so it doesn't feel mechanical

const jitter = delay * (0.85 + Math.random() * 0.3);

const finalDelay = Math.round(jitter);

// Keep the typing indicator alive during the delay

bot.sendChatAction(chatId, 'typing').catch(() => {});

return new Promise((resolve) => setTimeout(resolve, finalDelay));

// Shorter than the initial typing delay: 0.3s – 1.5s based on chunk length

const length = (nextChunk || '').length;

const base = Math.min(1500, Math.max(300, length * 8));

const jitter = base * (0.85 + Math.random() * 0.3);

bot.sendChatAction(chatId, 'typing').catch(() => {});

return new Promise((resolve) => setTimeout(resolve, Math.round(jitter)));

if (text.length <= maxLength) return [text];

const chunks = [];

let remaining = text;

while (remaining.length > 0) {

if (remaining.length <= maxLength) {

chunks.push(remaining);

break;

}

// Try to split at a newline near the limit

let splitAt = remaining.lastIndexOf('\n', maxLength);

if (splitAt < maxLength / 2) splitAt = maxLength;

chunks.push(remaining.slice(0, splitAt));

remaining = remaining.slice(splitAt);

}

return chunks;

const logger = getLogger();

return async (update, opts = {}) => {

if (opts.editMessageId) {

try {

const edited = await bot.editMessageText(update, {

chat_id: chatId,

message_id: opts.editMessageId,

parse_mode: 'Markdown',

});

return edited.message_id;

} catch (mdErr) {

logger.debug(`[Bot] Markdown edit failed for chat ${chatId}, retrying plain: ${mdErr.message}`);

try {

const edited = await bot.editMessageText(update, {

chat_id: chatId,

message_id: opts.editMessageId,

});

return edited.message_id;

} catch (plainErr) {

logger.debug(`[Bot] Plain-text edit also failed for chat ${chatId}, sending new message: ${plainErr.message}`);

}

}

}

const parts = splitMessage(update);

let lastMsgId = null;

for (const part of parts) {

try {

const sent = await bot.sendMessage(chatId, part, { parse_mode: 'Markdown' });

lastMsgId = sent.message_id;

} catch (mdErr) {

logger.debug(`[Bot] Markdown send failed for chat ${chatId}, falling back to plain: ${mdErr.message}`);

try {

const sent = await bot.sendMessage(chatId, part);

lastMsgId = sent.message_id;

} catch (plainErr) {

logger.error(`[Bot] Plain-text send also failed for chat ${chatId}: ${plainErr.message}`);

}

}

}

return lastMsgId;

};

return async (filePath, caption) => {

const fileOpts = { contentType: 'image/png' };

try {

await bot.sendPhoto(chatId, createReadStream(filePath), {

caption: caption || '',

parse_mode: 'Markdown',

}, fileOpts);

} catch {

try {

await bot.sendPhoto(chatId, createReadStream(filePath), {

caption: caption || '',

}, fileOpts);

} catch (err) {

logger.error(`Failed to send photo: ${err.message}`);

}

}

};

const logger = getLogger();

return async (targetChatId, targetMsgId, emoji, isBig = false) => {

try {

await bot.setMessageReaction(targetChatId, targetMsgId, {

reaction: [{ type: 'emoji', emoji }],

is_big: isBig,

});

} catch (err) {

logger.debug(`[Bot] Failed to set reaction for msg ${targetMsgId} in chat ${targetChatId}: ${err.message}`);

}

};

constructor() {

this.queues = new Map();

}

enqueue(chatId, fn) {

const logger = getLogger();

const key = String(chatId);

const prev = this.queues.get(key) || Promise.resolve();

const next = prev

.then(() => fn())

.catch((err) => {

logger.error(`[ChatQueue] Error processing message for chat ${key}: ${err.message}`);

})

.finally(() => {

// Clean up the queue entry once this is the last item in the chain,

// preventing the Map from growing unboundedly over long-running sessions.

if (this.queues.get(key) === next) {

this.queues.delete(key);

}

});

this.queues.set(key, next);

return next;

}

let { lifeEngine, memoryManager, journalManager, shareQueue, evolutionTracker, codebaseKnowledge, characterManager, dashboardHandle, dashboardDeps, consolidation, synthesisLoop, identityAwareness } = lifeDeps;

const logger = getLogger();

const bot = new TelegramBot(config.telegram.bot_token, {

polling: {

params: {

allowed_updates: ['message', 'callback_query', 'message_reaction'],

},

},

});

const chatQueue = new ChatQueue();

const batchWindowMs = config.telegram.batch_window_ms || 3000;

// Initialize voice services

const ttsService = new TTSService(config);

const sttService = new STTService(config);

if (ttsService.isAvailable()) logger.info('[Bot] TTS service enabled (ElevenLabs)');

if (sttService.isAvailable()) logger.info('[Bot] STT service enabled');

/**

function rebuildLifeEngine(charCtx) {

if (lifeEngine) {

lifeEngine.stop();

}

// Update module-level manager refs so other bot.js code uses the right ones

memoryManager = charCtx.memoryManager;

journalManager = charCtx.journalManager;

shareQueue = charCtx.shareQueue;

evolutionTracker = charCtx.evolutionTracker;

// Switch conversation file to the new character's conversations.json

conversationManager.switchFile(charCtx.conversationFilePath);

const lifeEnabled = config.life?.enabled !== false;

if (!lifeEnabled) {

lifeEngine = null;

return;

}

lifeEngine = new LifeEngine({

config,

agent,

memoryManager: charCtx.memoryManager,

journalManager: charCtx.journalManager,

shareQueue: charCtx.shareQueue,

evolutionTracker: charCtx.evolutionTracker,

codebaseKnowledge,

selfManager: charCtx.selfManager,

basePath: charCtx.lifeBasePath,

characterId: charCtx.characterId,

consolidation,

});

lifeEngine.wakeUp().then(() => {

lifeEngine.start();

logger.info(`[Bot] Life engine rebuilt for character: ${charCtx.characterId}`);

}).catch(err => {

logger.error(`[Bot] Life engine wake-up failed: ${err.message}`);

lifeEngine.start();

});

}

// ── Onboarding ──────────────────────────────────────────────────

let onboardingManager = null;

let onboardingFlow = null;

const onboardingEnabled = config.onboarding?.enabled !== false;

if (onboardingEnabled && agent._brainDB?.isOpen) {

onboardingManager = new OnboardingManager(agent._brainDB);

onboardingFlow = new OnboardingFlow({

onboardingManager,

provider: agent.orchestratorProvider,

characterName: config.bot?.name || 'KernelBot',

personaManager: agent.personaManager,

conversationManager,

identityAwareness,

});

agent.onboardingManager = onboardingManager;

logger.info('[Bot] Onboarding system initialized');

}

// Per-chat message batching: chatId -> { messages[], timer, resolve }

const chatBatches = new Map();

// Load previous conversations from disk

const loaded = conversationManager.load();

if (loaded) {

logger.info('Loaded previous conversations from disk');

}

// Load custom skills from disk

loadAllSkills();

// Register commands in Telegram's menu button

bot.setMyCommands([

{ command: 'character', description: 'Switch or manage characters' },

{ command: 'brain', description: 'Switch worker AI model/provider' },

{ command: 'orchestrator', description: 'Switch orchestrator AI model/provider' },

{ command: 'claudemodel', description: 'Switch Claude Code model' },

{ command: 'claude', description: 'Manage Claude Code authentication' },

{ command: 'skills', description: 'Browse and activate persona skills' },

{ command: 'jobs', description: 'List running and recent jobs' },

{ command: 'cancel', description: 'Cancel running job(s)' },

{ command: 'auto', description: 'Manage recurring automations' },

{ command: 'life', description: 'Inner life engine status and control' },

{ command: 'journal', description: 'View today\'s journal or a past date' },

{ command: 'memories', description: 'View recent memories or search' },

{ command: 'senders', description: 'List known senders with trust levels' },

{ command: 'whois', description: 'Show sender profile (/whois username)' },

{ command: 'trust', description: 'Promote user to trusted (/trust username)' },

{ command: 'restrict', description: 'Demote user to unknown (/restrict username)' },

{ command: 'registerbot', description: 'Register AI agent (/registerbot bot purpose)' },

{ command: 'privacy', description: 'Show knowledge scope stats' },

{ command: 'evolution', description: 'Self-evolution status, history, and lessons' },

{ command: 'linkedin', description: 'Link/unlink LinkedIn account' },

{ command: 'x', description: 'Link/unlink X (Twitter) account' },

{ command: 'dashboard', description: 'Start/stop the monitoring dashboard' },

{ command: 'onboarding', description: 'Show onboarding status or reset' },

{ command: 'context', description: 'Show all models, auth, and context info' },

{ command: 'clean', description: 'Clear conversation and start fresh' },

{ command: 'history', description: 'Show message count in memory' },

{ command: 'help', description: 'Show all available commands' },

]).catch((err) => logger.warn(`Failed to set bot commands menu: ${err.message}`));

logger.info('Telegram bot started with polling');

// Initialize automation manager with bot context

if (automationManager) {

const sendMsg = async (chatId, text) => {

try {

await bot.sendMessage(chatId, text, { parse_mode: 'Markdown' });

} catch {

await bot.sendMessage(chatId, text);

}

};

const sendAction = (chatId, action) => bot.sendChatAction(chatId, action).catch(() => {});

const agentFactory = (chatId) => {

const onUpdate = createOnUpdate(bot, chatId);

const sendPhoto = createSendPhoto(bot, chatId, logger);

return { agent, onUpdate, sendPhoto };

};

automationManager.init({ sendMessage: sendMsg, sendChatAction: sendAction, agentFactory, config });

automationManager.startAll();

logger.info('[Bot] Automation manager initialized and started');

}

// Track pending brain API key input: chatId -> { providerKey, modelId }

const pendingBrainKey = new Map();

// Track pending orchestrator API key input: chatId -> { providerKey, modelId }

const pendingOrchKey = new Map();

// Track pending Claude Code auth input: chatId -> { type: 'api_key' | 'oauth_token' }

const pendingClaudeAuth = new Map();

// Track pending custom skill creation: chatId -> { step: 'name' | 'prompt', name?: string }

const pendingCustomSkill = new Map();

// Track pending custom character build: chatId -> { answers: {}, step: number }

const pendingCharacterBuild = new Map();

// Track pending dashboard credential setup: chatId -> { step: 'username' | 'password', username?: string }

const pendingDashboardCreds = new Map();

// Handle inline keyboard callbacks for /brain

bot.on('callback_query', async (query) => {

const chatId = query.message.chat.id;

const data = query.data;

if (!isAllowedUser(query.from.id, config)) {

await bot.answerCallbackQuery(query.id, { text: 'Unauthorized' });

await alertAdmin(bot, {

userId: query.from.id,

username: query.from.username,

firstName: query.from.first_name,

text: `🔘 زر: ${query.data || 'unknown'}`,

type: 'callback',

});

return;

}

try {

logger.info(`[Bot] Callback query from chat ${chatId}: ${data}`);

if (data.startsWith('brain_provider:')) {

// User picked a provider — show model list

const providerKey = data.split(':')[1];

const providerDef = PROVIDERS[providerKey];

if (!providerDef) {

await bot.answerCallbackQuery(query.id, { text: 'Unknown provider' });

return;

}

const modelButtons = providerDef.models.map((m) => ([{

text: m.label,

callback_data: `brain_model:${providerKey}:${m.id}`,

}]));

modelButtons.push([{ text: 'Cancel', callback_data: 'brain_cancel' }]);

await bot.editMessageText(`Select a *${providerDef.name}* model:`, {

chat_id: chatId,

message_id: query.message.message_id,

parse_mode: 'Markdown',

reply_markup: { inline_keyboard: modelButtons },

});

await bot.answerCallbackQuery(query.id);

} else if (data.startsWith('brain_model:')) {

// User picked a model — attempt switch

// Use split with limit to avoid truncating model IDs containing colons

const parts = data.split(':');

const providerKey = parts[1];

const modelId = parts.slice(2).join(':');

const providerDef = PROVIDERS[providerKey];

const modelEntry = providerDef?.models.find((m) => m.id === modelId);

const modelLabel = modelEntry ? modelEntry.label : modelId;

await bot.editMessageText(

`⏳ Verifying *${providerDef.name}* / *${modelLabel}*...`,

{

chat_id: chatId,

message_id: query.message.message_id,

parse_mode: 'Markdown',

},

);

logger.info(`[Bot] Brain switch request: ${providerKey}/${modelId} from chat ${chatId}`);

const result = await agent.switchBrain(providerKey, modelId);

if (result && typeof result === 'object' && result.error) {

// Validation failed — keep current model

logger.warn(`[Bot] Brain switch failed: ${result.error}`);

const current = agent.getBrainInfo();

await bot.editMessageText(

`❌ Failed to switch: ${result.error}\n\nKeeping *${current.providerName}* / *${current.modelLabel}*`,

{

chat_id: chatId,

message_id: query.message.message_id,

parse_mode: 'Markdown',

},

);

} else if (result) {

// API key missing — ask for it

logger.info(`[Bot] Brain switch needs API key: ${result} for ${providerKey}/${modelId}`);

pendingBrainKey.set(chatId, { providerKey, modelId });

await bot.editMessageText(

`🔑 *${providerDef.name}* API key is required.\n\nPlease send your \`${result}\` now.\n\nOr send *cancel* to abort.`,

{

chat_id: chatId,

message_id: query.message.message_id,

parse_mode: 'Markdown',

},

);

} else {

const info = agent.getBrainInfo();

logger.info(`[Bot] Brain switched successfully to ${info.providerName}/${info.modelLabel}`);

await bot.editMessageText(

`🧠 Brain switched to *${info.providerName}* / *${info.modelLabel}*`,

{

chat_id: chatId,

message_id: query.message.message_id,

parse_mode: 'Markdown',

},

);

}

await bot.answerCallbackQuery(query.id);

} else if (data === 'brain_cancel') {

pendingBrainKey.delete(chatId);

await bot.editMessageText('Brain change cancelled.', {

chat_id: chatId,

message_id: query.message.message_id,

});

await bot.answerCallbackQuery(query.id);

// ── Skill callbacks (multi-skill toggle) ─────────────────────

} else if (data.startsWith('skill_category:')) {

const categoryKey = data.split(':')[1];

const skills = getSkillsByCategory(categoryKey);

const categories = getCategoryList();

const cat = categories.find((c) => c.key === categoryKey);

if (!skills.length) {

await bot.answerCallbackQuery(query.id, { text: 'No skills in this category' });

return;

}

const activeIds = new Set(agent.getActiveSkillIds(chatId));

const buttons = skills.map((s) => ([{

text: `${activeIds.has(s.id) ? '✅ ' : ''}${s.emoji} ${s.name}`,

callback_data: `skill_toggle:${s.id}:${categoryKey}`,

}]));

buttons.push([

{ text: '« Back', callback_data: 'skill_back' },

{ text: 'Done', callback_data: 'skill_cancel' },

]);

const activeSkills = agent.getActiveSkills(chatId);

const activeLine = activeSkills.length > 0

? `Active (${activeSkills.length}): ${activeSkills.map(s => `${s.emoji} ${s.name}`).join(', ')}\n\n`

: '';

await bot.editMessageText(

`${activeLine}${cat ? cat.emoji : ''} *${cat ? cat.name : categoryKey}* — tap to toggle:`,

{

chat_id: chatId,

message_id: query.message.message_id,

parse_mode: 'Markdown',

reply_markup: { inline_keyboard: buttons },

},

);

await bot.answerCallbackQuery(query.id);

} else if (data.startsWith('skill_toggle:')) {

const parts = data.split(':');

const skillId = parts[1];

const categoryKey = parts[2]; // to refresh the category view

const skill = getSkillById(skillId);

if (!skill) {

await bot.answerCallbackQuery(query.id, { text: 'Unknown skill' });

return;

}

const { added, skills: currentSkills } = agent.toggleSkill(chatId, skillId);

if (!added && currentSkills.includes(skillId)) {

// Wasn't added because at max

await bot.answerCallbackQuery(query.id, { text: `Max ${5} skills reached. Remove one first.` });

return;

}

logger.info(`[Bot] Skill ${added ? 'activated' : 'deactivated'}: ${skill.name} (${skillId}) for chat ${chatId} — now ${currentSkills.length} active`);

// Refresh the category view with updated toggles

const catSkills = getSkillsByCategory(categoryKey);

const categories = getCategoryList();

const cat = categories.find((c) => c.key === categoryKey);

const activeIds = new Set(agent.getActiveSkillIds(chatId));

const buttons = catSkills.map((s) => ([{

text: `${activeIds.has(s.id) ? '✅ ' : ''}${s.emoji} ${s.name}`,

callback_data: `skill_toggle:${s.id}:${categoryKey}`,

}]));

buttons.push([

{ text: '« Back', callback_data: 'skill_back' },

{ text: 'Done', callback_data: 'skill_cancel' },

]);

const activeSkills = agent.getActiveSkills(chatId);

const activeLine = activeSkills.length > 0

? `Active (${activeSkills.length}): ${activeSkills.map(s => `${s.emoji} ${s.name}`).join(', ')}\n\n`

: '';

await bot.editMessageText(

`${activeLine}${cat ? cat.emoji : ''} *${cat ? cat.name : categoryKey}* — tap to toggle:`,

{

chat_id: chatId,

message_id: query.message.message_id,

parse_mode: 'Markdown',

reply_markup: { inline_keyboard: buttons },

},

);

await bot.answerCallbackQuery(query.id, { text: added ? `✅ ${skill.name} on` : `❌ ${skill.name} off` });

} else if (data === 'skill_reset') {

logger.info(`[Bot] Skills cleared for chat ${chatId}`);

agent.clearSkill(chatId);

await bot.editMessageText('🔄 All skills cleared — back to default persona.', {

chat_id: chatId,

message_id: query.message.message_id,

});

await bot.answerCallbackQuery(query.id);

} else if (data === 'skill_custom_add') {

pendingCustomSkill.set(chatId, { step: 'name' });

await bot.editMessageText(

'✏️ Send me a *name* for your custom skill:',

{

chat_id: chatId,

message_id: query.message.message_id,

parse_mode: 'Markdown',

},

);

await bot.answerCallbackQuery(query.id);

} else if (data === 'skill_custom_manage') {

const customs = getCustomSkills();

if (!customs.length) {

await bot.answerCallbackQuery(query.id, { text: 'No custom skills yet' });

return;

}

const buttons = customs.map((s) => ([{

text: `🗑️ ${s.name}`,

callback_data: `skill_custom_delete:${s.id}`,

}]));

buttons.push([{ text: '« Back', callback_data: 'skill_back' }]);

await bot.editMessageText('🛠️ *Custom Skills* — tap to delete:', {

chat_id: chatId,

message_id: query.message.message_id,

parse_mode: 'Markdown',

reply_markup: { inline_keyboard: buttons },

});

await bot.answerCallbackQuery(query.id);

} else if (data.startsWith('skill_custom_delete:')) {

const skillId = data.slice('skill_custom_delete:'.length);

logger.info(`[Bot] Custom skill delete request: ${skillId} from chat ${chatId}`);

// Remove from active skills if present

const activeIds = agent.getActiveSkillIds(chatId);

if (activeIds.includes(skillId)) {

logger.info(`[Bot] Removing deleted skill from active set: ${skillId}`);

agent.toggleSkill(chatId, skillId);

}

const deleted = deleteCustomSkill(skillId);

const msg = deleted ? '🗑️ Custom skill deleted.' : 'Skill not found.';

await bot.editMessageText(msg, {

chat_id: chatId,

message_id: query.message.message_id,

});

await bot.answerCallbackQuery(query.id);

} else if (data === 'skill_back') {

// Re-show category list

const categories = getCategoryList();

const activeSkills = agent.getActiveSkills(chatId);

const buttons = categories.map((cat) => ([{

text: `${cat.emoji} ${cat.name} (${cat.count})`,

callback_data: `skill_category:${cat.key}`,

}]));

// Custom skill management row

const customRow = [{ text: '➕ Add Custom', callback_data: 'skill_custom_add' }];

if (getCustomSkills().length > 0) {

customRow.push({ text: '🗑️ Manage Custom', callback_data: 'skill_custom_manage' });

}

buttons.push(customRow);

const footerRow = [{ text: 'Done', callback_data: 'skill_cancel' }];

if (activeSkills.length > 0) {

footerRow.unshift({ text: '🔄 Clear All', callback_data: 'skill_reset' });

}

buttons.push(footerRow);

const activeLine = activeSkills.length > 0

? `Active (${activeSkills.length}): ${activeSkills.map(s => `${s.emoji} ${s.name}`).join(', ')}\n\n`

: '';

const header = `${activeLine}🎭 *Skills* — select a category:`;

await bot.editMessageText(header, {

chat_id: chatId,

message_id: query.message.message_id,

parse_mode: 'Markdown',

reply_markup: { inline_keyboard: buttons },

});

await bot.answerCallbackQuery(query.id);

} else if (data === 'skill_cancel') {

const activeSkills = agent.getActiveSkills(chatId);

const msg = activeSkills.length > 0

? `🎭 Active skills (${activeSkills.length}): ${activeSkills.map(s => `${s.emoji} ${s.name}`).join(', ')}`

: 'No skills active.';

await bot.editMessageText(msg, {

chat_id: chatId,

message_id: query.message.message_id,

parse_mode: 'Markdown',

});

await bot.answerCallbackQuery(query.id);

// ── Job cancellation callbacks ────────────────────────────────

} else if (data.startsWith('cancel_job:')) {

const jobId = data.slice('cancel_job:'.length);

logger.info(`[Bot] Job cancel request via callback: ${jobId} from chat ${chatId}`);

const job = jobManager.cancelJob(jobId);

if (job) {

logger.info(`[Bot] Job cancelled via callback: ${jobId} [${job.workerType}]`);

await bot.editMessageText(`🚫 Cancelled job \`${jobId}\` (${job.workerType})`, {

chat_id: chatId,

message_id: query.message.message_id,

parse_mode: 'Markdown',

});

} else {

await bot.editMessageText(`Job \`${jobId}\` not found or already finished.`, {

chat_id: chatId,

message_id: query.message.message_id,

parse_mode: 'Markdown',

});

}

await bot.answerCallbackQuery(query.id);

} else if (data === 'cancel_all_jobs') {

logger.info(`[Bot] Cancel all jobs request via callback from chat ${chatId}`);

const cancelled = jobManager.cancelAllForChat(chatId);

const msg = cancelled.length > 0

? `🚫 Cancelled ${cancelled.length} job(s).`

: 'No running jobs to cancel.';

await bot.editMessageText(msg, {

chat_id: chatId,

message_id: query.message.message_id,

});

await bot.answerCallbackQuery(query.id);

// ── Automation callbacks ─────────────────────────────────────────

} else if (data.startsWith('auto_pause:')) {

const autoId = data.slice('auto_pause:'.length);

logger.info(`[Bot] Automation pause request: ${autoId} from chat ${chatId}`);

const auto = automationManager?.update(autoId, { enabled: false });

const msg = auto ? `⏸️ Paused automation \`${autoId}\` (${auto.name})` : `Automation \`${autoId}\` not found.`;