kernelbot 1.0.33 → 1.0.34

package/bin/kernel.js

@@ -9,7 +9,7 @@ import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import chalk from 'chalk';
-import { loadConfig, loadConfigInteractive, changeBrainModel } from '../src/utils/config.js';
+import { loadConfig, loadConfigInteractive, changeBrainModel, changeOrchestratorModel } from '../src/utils/config.js';
 import { createLogger, getLogger } from '../src/utils/logger.js';
 import {
   showLogo,
@@ -40,11 +40,16 @@ import {
 } from '../src/skills/custom.js';
 
 function showMenu(config) {
+  const orchProviderDef = PROVIDERS[config.orchestrator.provider];
+  const orchProviderName = orchProviderDef ? orchProviderDef.name : config.orchestrator.provider;
+  const orchModelId = config.orchestrator.model;
+
   const providerDef = PROVIDERS[config.brain.provider];
   const providerName = providerDef ? providerDef.name : config.brain.provider;
   const modelId = config.brain.model;
 
   console.log('');
+  console.log(chalk.dim(`  Current orchestrator: ${orchProviderName} / ${orchModelId}`));
   console.log(chalk.dim(`  Current brain: ${providerName} / ${modelId}`));
   console.log('');
   console.log(chalk.bold('  What would you like to do?\n'));
@@ -53,9 +58,10 @@ function showMenu(config) {
   console.log(`  ${chalk.cyan('3.')} View logs`);
   console.log(`  ${chalk.cyan('4.')} View audit logs`);
   console.log(`  ${chalk.cyan('5.')} Change brain model`);
-  console.log(`  ${chalk.cyan('6.')} Manage custom skills`);
-  console.log(`  ${chalk.cyan('7.')} Manage automations`);
-  console.log(`  ${chalk.cyan('8.')} Exit`);
+  console.log(`  ${chalk.cyan('6.')} Change orchestrator model`);
+  console.log(`  ${chalk.cyan('7.')} Manage custom skills`);
+  console.log(`  ${chalk.cyan('8.')} Manage automations`);
+  console.log(`  ${chalk.cyan('9.')} Exit`);
   console.log('');
 }
 
@@ -95,23 +101,53 @@ function viewLog(filename) {
 }
 
 async function runCheck(config) {
+  // Orchestrator check
+  const orchProviderKey = config.orchestrator.provider || 'anthropic';
+  const orchProviderDef = PROVIDERS[orchProviderKey];
+  const orchLabel = orchProviderDef ? orchProviderDef.name : orchProviderKey;
+  const orchEnvKey = orchProviderDef ? orchProviderDef.envKey : 'ANTHROPIC_API_KEY';
+
+  await showStartupCheck(`Orchestrator ${orchEnvKey}`, async () => {
+    const orchestratorKey = config.orchestrator.api_key
+      || (orchProviderDef && process.env[orchProviderDef.envKey])
+      || process.env.ANTHROPIC_API_KEY;
+    if (!orchestratorKey) throw new Error('Not set');
+  });
+
+  await showStartupCheck(`Orchestrator (${orchLabel}) API connection`, async () => {
+    const orchestratorKey = config.orchestrator.api_key
+      || (orchProviderDef && process.env[orchProviderDef.envKey])
+      || process.env.ANTHROPIC_API_KEY;
+    const provider = createProvider({
+      brain: {
+        provider: orchProviderKey,
+        model: config.orchestrator.model,
+        max_tokens: config.orchestrator.max_tokens,
+        temperature: config.orchestrator.temperature,
+        api_key: orchestratorKey,
+      },
+    });
+    await provider.ping();
+  });
+
+  // Worker brain check
   const providerDef = PROVIDERS[config.brain.provider];
   const providerLabel = providerDef ? providerDef.name : config.brain.provider;
   const envKeyLabel = providerDef ? providerDef.envKey : 'API_KEY';
 
-  await showStartupCheck(envKeyLabel, async () => {
+  await showStartupCheck(`Worker ${envKeyLabel}`, async () => {
     if (!config.brain.api_key) throw new Error('Not set');
   });
 
-  await showStartupCheck('TELEGRAM_BOT_TOKEN', async () => {
-    if (!config.telegram.bot_token) throw new Error('Not set');
-  });
-
-  await showStartupCheck(`${providerLabel} API connection`, async () => {
+  await showStartupCheck(`Worker (${providerLabel}) API connection`, async () => {
     const provider = createProvider(config);
     await provider.ping();
   });
 
+  await showStartupCheck('TELEGRAM_BOT_TOKEN', async () => {
+    if (!config.telegram.bot_token) throw new Error('Not set');
+  });
+
   await showStartupCheck('Telegram Bot API', async () => {
     const res = await fetch(
       `https://api.telegram.org/bot${config.telegram.bot_token}/getMe`,
@@ -429,12 +465,15 @@ async function main() {
         await changeBrainModel(config, rl);
         break;
       case '6':
-        await manageCustomSkills(rl);
+        await changeOrchestratorModel(config, rl);
         break;
       case '7':
-        await manageAutomations(rl);
+        await manageCustomSkills(rl);
         break;
       case '8':
+        await manageAutomations(rl);
+        break;
+      case '9':
         running = false;
         break;
       default:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kernelbot",
-  "version": "1.0.33",
+  "version": "1.0.34",
   "description": "KernelBot — AI engineering agent with full OS control",
   "type": "module",
   "author": "Abdullah Al-Taheri <abdullah@altaheri.me>",
@@ -31,6 +31,7 @@
   "license": "MIT",
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
+    "@google/genai": "^1.42.0",
     "@octokit/rest": "^22.0.1",
     "axios": "^1.13.5",
     "boxen": "^8.0.1",

package/src/agent.js

@@ -9,9 +9,7 @@ import { WorkerAgent } from './worker.js';
 import { getLogger } from './utils/logger.js';
 import { getMissingCredential, saveCredential, saveProviderToYaml, saveOrchestratorToYaml, saveClaudeCodeModelToYaml, saveClaudeCodeAuth } from './utils/config.js';
 import { resetClaudeCodeSpawner, getSpawner } from './tools/coding.js';
-
-const MAX_RESULT_LENGTH = 3000;
-const LARGE_FIELDS = ['stdout', 'stderr', 'content', 'diff', 'output', 'body', 'html', 'text', 'log', 'logs'];
+import { truncateToolResult } from './utils/truncate.js';
 
 export class OrchestratorAgent {
   constructor({ config, conversationManager, personaManager, selfManager, jobManager, automationManager, memoryManager, shareQueue }) {
@@ -282,23 +280,9 @@ export class OrchestratorAgent {
     }
   }
 
-  /** Truncate a tool result. */
+  /** Truncate a tool result. Delegates to shared utility. */
   _truncateResult(name, result) {
-    let str = JSON.stringify(result);
-    if (str.length <= MAX_RESULT_LENGTH) return str;
-
-    if (result && typeof result === 'object') {
-      const truncated = { ...result };
-      for (const field of LARGE_FIELDS) {
-        if (typeof truncated[field] === 'string' && truncated[field].length > 500) {
-          truncated[field] = truncated[field].slice(0, 500) + `\n... [truncated ${truncated[field].length - 500} chars]`;
-        }
-      }
-      str = JSON.stringify(truncated);
-      if (str.length <= MAX_RESULT_LENGTH) return str;
-    }
-
-    return str.slice(0, MAX_RESULT_LENGTH) + `\n... [truncated, total ${str.length} chars]`;
+    return truncateToolResult(name, result);
   }
 
   async processMessage(chatId, userMessage, user, onUpdate, sendPhoto, opts = {}) {
@@ -1021,6 +1005,151 @@ export class OrchestratorAgent {
     }
   }
 
+  /**
+   * Resume active chats after a restart.
+   * Checks recent conversations for pending items and sends follow-up messages.
+   * Called once from bot.js after startup.
+   */
+  async resumeActiveChats(sendMessageFn) {
+    const logger = getLogger();
+    const now = Date.now();
+    const MAX_AGE_MS = 24 * 60 * 60_000; // 24 hours
+
+    logger.info('[Orchestrator] Checking for active chats to resume...');
+
+    let resumeCount = 0;
+
+    for (const [chatId, messages] of this.conversationManager.conversations) {
+      // Skip internal life engine chat
+      if (chatId === '__life__') continue;
+
+      try {
+        // Find the last message with a timestamp
+        const lastMsg = [...messages].reverse().find(m => m.timestamp);
+        if (!lastMsg || !lastMsg.timestamp) continue;
+
+        const ageMs = now - lastMsg.timestamp;
+        if (ageMs > MAX_AGE_MS) continue;
+
+        // Calculate time gap for context
+        const gapMinutes = Math.floor(ageMs / 60_000);
+        const gapText = gapMinutes >= 60
+          ? `${Math.floor(gapMinutes / 60)} hour(s)`
+          : `${gapMinutes} minute(s)`;
+
+        // Build summarized history
+        const history = this.conversationManager.getSummarizedHistory(chatId);
+        if (history.length === 0) continue;
+
+        // Build resume prompt
+        const resumePrompt = `[System Restart] You just came back online after being offline for ${gapText}. Review the conversation above.\nIf there's something pending (unfinished task, follow-up, something to share), send a short natural message. If nothing's pending, respond with exactly: NONE`;
+
+        // Use minimal user object (private TG chats: chatId == userId)
+        const user = { id: chatId };
+
+        const response = await this.orchestratorProvider.chat({
+          system: this._getSystemPrompt(chatId, user),
+          messages: [
+            ...history,
+            { role: 'user', content: resumePrompt },
+          ],
+        });
+
+        const reply = (response.text || '').trim();
+
+        if (reply && reply !== 'NONE') {
+          await sendMessageFn(chatId, reply);
+          this.conversationManager.addMessage(chatId, 'assistant', reply);
+          resumeCount++;
+          logger.info(`[Orchestrator] Resume message sent to chat ${chatId}`);
+        } else {
+          logger.debug(`[Orchestrator] No resume needed for chat ${chatId}`);
+        }
+
+        // Small delay between chats to avoid rate limiting
+        await new Promise(r => setTimeout(r, 1000));
+      } catch (err) {
+        logger.error(`[Orchestrator] Resume failed for chat ${chatId}: ${err.message}`);
+      }
+    }
+
+    logger.info(`[Orchestrator] Resume check complete — ${resumeCount} message(s) sent`);
+  }
+
+  /**
+   * Deliver pending shares from the life engine to active chats proactively.
+   * Called periodically from bot.js.
+   */
+  async deliverPendingShares(sendMessageFn) {
+    const logger = getLogger();
+
+    if (!this.shareQueue) return;
+
+    const pending = this.shareQueue.getPending(null, 5);
+    if (pending.length === 0) return;
+
+    const now = Date.now();
+    const MAX_AGE_MS = 24 * 60 * 60_000;
+
+    // Find active chats (last message within 24h)
+    const activeChats = [];
+    for (const [chatId, messages] of this.conversationManager.conversations) {
+      if (chatId === '__life__') continue;
+      const lastMsg = [...messages].reverse().find(m => m.timestamp);
+      if (lastMsg && lastMsg.timestamp && (now - lastMsg.timestamp) < MAX_AGE_MS) {
+        activeChats.push(chatId);
+      }
+    }
+
+    if (activeChats.length === 0) {
+      logger.debug('[Orchestrator] No active chats for share delivery');
+      return;
+    }
+
+    logger.info(`[Orchestrator] Delivering ${pending.length} pending share(s) to ${activeChats.length} active chat(s)`);
+
+    // Cap at 3 chats per cycle to avoid spam
+    const targetChats = activeChats.slice(0, 3);
+
+    for (const chatId of targetChats) {
+      try {
+        const history = this.conversationManager.getSummarizedHistory(chatId);
+        const user = { id: chatId };
+
+        // Build shares into a prompt
+        const sharesText = pending.map((s, i) => `${i + 1}. [${s.source}] ${s.content}`).join('\n');
+
+        const sharePrompt = `[Proactive Share] You have some discoveries and thoughts you'd like to share naturally. Here they are:\n\n${sharesText}\n\nWeave one or more of these into a short, natural message. Don't be forced — pick what feels relevant to this user and conversation. If none feel right for this chat, respond with exactly: NONE`;
+
+        const response = await this.orchestratorProvider.chat({
+          system: this._getSystemPrompt(chatId, user),
+          messages: [
+            ...history,
+            { role: 'user', content: sharePrompt },
+          ],
+        });
+
+        const reply = (response.text || '').trim();
+
+        if (reply && reply !== 'NONE') {
+          await sendMessageFn(chatId, reply);
+          this.conversationManager.addMessage(chatId, 'assistant', reply);
+          logger.info(`[Orchestrator] Proactive share delivered to chat ${chatId}`);
+
+          // Mark shares as delivered for this user
+          for (const item of pending) {
+            this.shareQueue.markShared(item.id, chatId);
+          }
+        }
+
+        // Delay between chats
+        await new Promise(r => setTimeout(r, 2000));
+      } catch (err) {
+        logger.error(`[Orchestrator] Share delivery failed for chat ${chatId}: ${err.message}`);
+      }
+    }
+  }
+
   /** Background persona extraction. */
   async _extractPersonaBackground(userMessage, reply, user) {
     const logger = getLogger();

package/src/bot.js

@@ -16,6 +16,33 @@ import { TTSService } from './services/tts.js';
 import { STTService } from './services/stt.js';
 import { getClaudeAuthStatus, claudeLogout } from './claude-auth.js';
 
+/**
+ * Simulate a human-like typing delay based on response length.
+ * Short replies (casual chat) get a brief pause; longer replies get more.
+ * Keeps the typing indicator alive during the delay so the user sees "typing...".
+ *
+ * @param {TelegramBot} bot - Telegram bot instance
+ * @param {number} chatId - Chat to show typing in
+ * @param {string} text - The reply text (used to calculate delay)
+ * @returns {Promise<void>}
+ */
+async function simulateTypingDelay(bot, chatId, text) {
+  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));
+}
+
 function splitMessage(text, maxLength = 4096) {
   if (text.length <= maxLength) return [text];
 
@@ -35,6 +62,83 @@ function splitMessage(text, maxLength = 4096) {
   return chunks;
 }
 
+/**
+ * Create an onUpdate callback that sends or edits Telegram messages.
+ * Tries Markdown first, falls back to plain text.
+ */
+function createOnUpdate(bot, chatId) {
+  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 {
+        try {
+          const edited = await bot.editMessageText(update, {
+            chat_id: chatId,
+            message_id: opts.editMessageId,
+          });
+          return edited.message_id;
+        } catch {
+          // Edit failed — fall through to send new 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 {
+        const sent = await bot.sendMessage(chatId, part);
+        lastMsgId = sent.message_id;
+      }
+    }
+    return lastMsgId;
+  };
+}
+
+/**
+ * Create a sendPhoto callback that sends a photo with optional caption.
+ * Tries Markdown caption first, falls back to plain caption.
+ */
+function createSendPhoto(bot, chatId, logger) {
+  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}`);
+      }
+    }
+  };
+}
+
+/**
+ * Create a sendReaction callback for reacting to messages with emoji.
+ */
+function createSendReaction(bot) {
+  return async (targetChatId, targetMsgId, emoji, isBig = false) => {
+    await bot.setMessageReaction(targetChatId, targetMsgId, {
+      reaction: [{ type: 'emoji', emoji }],
+      is_big: isBig,
+    });
+  };
+}
+
 /**
  * Simple per-chat queue to serialize agent processing.
  * Each chat gets its own promise chain so messages are processed in order.
@@ -119,54 +223,8 @@ export function startBot(config, agent, conversationManager, jobManager, automat
     const sendAction = (chatId, action) => bot.sendChatAction(chatId, action).catch(() => {});
 
     const agentFactory = (chatId) => {
-      const onUpdate = 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 {
-            try {
-              const edited = await bot.editMessageText(update, {
-                chat_id: chatId,
-                message_id: opts.editMessageId,
-              });
-              return edited.message_id;
-            } catch {
-              // Edit failed — fall through to send new 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 {
-            const sent = await bot.sendMessage(chatId, part);
-            lastMsgId = sent.message_id;
-          }
-        }
-        return lastMsgId;
-      };
-
-      const sendPhoto = 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(`[Automation] Failed to send photo: ${err.message}`);
-          }
-        }
-      };
-
+      const onUpdate = createOnUpdate(bot, chatId);
+      const sendPhoto = createSendPhoto(bot, chatId, logger);
       return { agent, onUpdate, sendPhoto };
     };
 
@@ -1580,68 +1638,9 @@ export function startBot(config, agent, conversationManager, jobManager, automat
       bot.sendChatAction(chatId, 'typing').catch(() => {});
 
       try {
-        const onUpdate = async (update, opts = {}) => {
-          // Edit an existing message instead of sending a new one
-          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 {
-              try {
-                const edited = await bot.editMessageText(update, {
-                  chat_id: chatId,
-                  message_id: opts.editMessageId,
-                });
-                return edited.message_id;
-              } catch {
-                // Edit failed — fall through to send new message
-              }
-            }
-          }
-
-          // Send new message(s) — also reached when edit fails
-          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 {
-              const sent = await bot.sendMessage(chatId, part);
-              lastMsgId = sent.message_id;
-            }
-          }
-          return lastMsgId;
-        };
-
-        const sendPhoto = 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 sendReaction = async (targetChatId, targetMsgId, emoji, isBig = false) => {
-          await bot.setMessageReaction(targetChatId, targetMsgId, {
-            reaction: [{ type: 'emoji', emoji }],
-            is_big: isBig,
-          });
-        };
+        const onUpdate = createOnUpdate(bot, chatId);
+        const sendPhoto = createSendPhoto(bot, chatId, logger);
+        const sendReaction = createSendReaction(bot);
 
         logger.debug(`[Bot] Sending to orchestrator: chat ${chatId}, text="${mergedText.slice(0, 80)}"`);
         const reply = await agent.processMessage(chatId, mergedText, {
@@ -1651,6 +1650,9 @@ export function startBot(config, agent, conversationManager, jobManager, automat
 
         clearInterval(typingInterval);
 
+        // Simulate human-like typing delay before sending the reply
+        await simulateTypingDelay(bot, chatId, reply || '');
+
         logger.info(`[Bot] Reply for chat ${chatId}: ${(reply || '').length} chars`);
         const chunks = splitMessage(reply || 'Done.');
         for (const chunk of chunks) {
@@ -1702,47 +1704,8 @@ export function startBot(config, agent, conversationManager, jobManager, automat
 
     chatQueue.enqueue(chatId, async () => {
       try {
-        const onUpdate = 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 {
-              try {
-                const edited = await bot.editMessageText(update, {
-                  chat_id: chatId,
-                  message_id: opts.editMessageId,
-                });
-                return edited.message_id;
-              } catch {
-                // fall through
-              }
-            }
-          }
-          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 {
-              const sent = await bot.sendMessage(chatId, part);
-              lastMsgId = sent.message_id;
-            }
-          }
-          return lastMsgId;
-        };
-
-        const sendReaction = async (targetChatId, targetMsgId, emoji, isBig = false) => {
-          await bot.setMessageReaction(targetChatId, targetMsgId, {
-            reaction: [{ type: 'emoji', emoji }],
-            is_big: isBig,
-          });
-        };
+        const onUpdate = createOnUpdate(bot, chatId);
+        const sendReaction = createSendReaction(bot);
 
         const reply = await agent.processMessage(chatId, reactionText, {
           id: userId,
@@ -1769,5 +1732,68 @@ export function startBot(config, agent, conversationManager, jobManager, automat
     logger.error(`Telegram polling error: ${err.message}`);
   });
 
+  // ── Resume active chats after restart ────────────────────────
+  setTimeout(async () => {
+    const sendMsg = async (chatId, text) => {
+      try {
+        await bot.sendMessage(chatId, text, { parse_mode: 'Markdown' });
+      } catch {
+        await bot.sendMessage(chatId, text);
+      }
+    };
+    try {
+      await agent.resumeActiveChats(sendMsg);
+    } catch (err) {
+      logger.error(`[Bot] Resume active chats failed: ${err.message}`);
+    }
+  }, 5000);
+
+  // ── Proactive share delivery (randomized, self-rearming) ────
+  const lifeConfig = config.life || {};
+  const quietStart = lifeConfig.quiet_hours?.start ?? 2;
+  const quietEnd = lifeConfig.quiet_hours?.end ?? 6;
+
+  const armShareDelivery = (delivered) => {
+    // If we just delivered something, wait longer (1–4h) before next check
+    // If nothing was delivered, check again sooner (10–45min) in case new shares appear
+    const minMin = delivered ? 60 : 10;
+    const maxMin = delivered ? 240 : 45;
+    const delayMs = (minMin + Math.random() * (maxMin - minMin)) * 60_000;
+
+    logger.debug(`[Bot] Next share check in ${Math.round(delayMs / 60_000)}m`);
+
+    setTimeout(async () => {
+      // Respect quiet hours
+      const hour = new Date().getHours();
+      if (hour >= quietStart && hour < quietEnd) {
+        armShareDelivery(false);
+        return;
+      }
+
+      const sendMsg = async (chatId, text) => {
+        try {
+          await bot.sendMessage(chatId, text, { parse_mode: 'Markdown' });
+        } catch {
+          await bot.sendMessage(chatId, text);
+        }
+      };
+
+      let didDeliver = false;
+      try {
+        const before = shareQueue ? shareQueue.getPending(null, 1).length : 0;
+        await agent.deliverPendingShares(sendMsg);
+        const after = shareQueue ? shareQueue.getPending(null, 1).length : 0;
+        didDeliver = before > 0 && after < before;
+      } catch (err) {
+        logger.error(`[Bot] Proactive share delivery failed: ${err.message}`);
+      }
+
+      armShareDelivery(didDeliver);
+    }, delayMs);
+  };
+
+  // Start the first check after a random 10–30 min
+  armShareDelivery(false);
+
   return bot;
 }