alvin-bot 4.8.7 → 4.8.8

package/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 All notable changes to Alvin Bot are documented here.
 
+## [4.8.8] — 2026-04-11
+
+### ✨ Unlimited sub-agent & cron timeouts (user-configurable)
+
+Sub-agents and `ai-query` cron jobs used to hard-cap at 5 minutes (`SUBAGENT_TIMEOUT=300000` default), and `shell` cron jobs at 60 s. Long-running research, deep-dive audits, or anything that crossed the threshold got killed mid-stream with `status: "timeout"`. 4.8.8 flips the default to **unlimited** and lets the user override both globally and per job.
+
+**What changed:**
+
+- **Default is now infinite.** `src/config.ts` seeds `subAgentTimeout` from `SUBAGENT_TIMEOUT` env or falls back to `-1` (unlimited). The runtime value lives in `~/.alvin-bot/sub-agents.json` as `defaultTimeoutMs` and is changeable at runtime without restart.
+- **New `/subagents timeout` command.** `/subagents timeout` shows the current value; `/subagents timeout 3600` sets 1 h; `/subagents timeout off` (or `-1`, `0`, `unlimited`, `infinite`) disables the cap entirely. The default-status output now includes a `⏱ Timeout` line.
+- **Per-job override on cron.** `/cron add 1h ai-query "deep audit" --timeout off` gives this one job no timeout. `/cron add 5m shell "pm2 ls" --timeout 30` caps this shell at 30 s. Omitting `--timeout` inherits the current global default. Same flag exists on `scripts/cron-manage.js add --timeout <sec|off>`.
+- **`CronJob.timeoutMs` field.** Optional number in `cron-jobs.json`. Undefined = inherit global default. Value ≤ 0 = unlimited.
+- **Semantics.** `spawnSubAgent` now only arms the `setTimeout(abort)` when `timeout > 0`. At ≤ 0, no abort timer is created, existing `if (timeoutId) clearTimeout(…)` call sites are null-safe, and the agent runs until it finishes, is cancelled via `/subagents cancel`, or the process dies.
+- **Shell cron unchanged behaviour preserved.** If the shell job has no `timeoutMs`, `execSync` is called without a `timeout` option, which Node treats as infinite — same effect as before was *meant* to provide, but the old hard-coded 60 s removed that freedom.
+
+**ENV var still works but is seed-only.** `SUBAGENT_TIMEOUT=600000` at startup still seeds the config on first load, but the persisted value in `sub-agents.json` wins after that.
+
+### 🐛 Silenced harmless `message is not modified` Telegram errors
+
+Occasionally Ali would see a red banner at the bottom of an Alvin message:
+
+> Error: Call to 'editMessageText' failed! (400: Bad Request: message is not modified: specified new message content and reply markup are exactly the same as a current content and reply markup of the message)
+
+It never broke anything, but it polluted logs and showed up as an "internal error" reply to the user. Root cause: Telegram's Bot API refuses `editMessageText` when the new content + reply markup are byte-identical to the existing message. This happens legitimately in callback handlers — e.g. tapping a cron-toggle button twice, re-rendering a sudo/keys/platforms menu, language-switch callbacks that render the same content, or stream flushes where the throttled partial hasn't changed since the last edit.
+
+**Fix**: `bot.catch()` in `src/index.ts` now filters out this specific error early. Two regex patterns (`/message is not modified/i` and `/specified new message content.*exactly the same/i`) cover both variants Telegram sends. Real errors (network, SDK, provider failures) still log and still surface the "internal error" reply to the user — only this one harmless class gets dropped.
+
+### 📝 CLAUDE.md: PM2 references updated to launchd
+
+The project `CLAUDE.md` still said *"PM2: `alvin-bot` Prozess, Config in `ecosystem.config.cjs`"* — outdated since the 4.8.6 switch to launchd. Updated to reflect the actual process manager (`~/Library/LaunchAgents/com.alvinbot.app.plist`, `KeepAlive=true`, `RunAtLoad=true`), the log paths, and a note that `watchdog.ts` only brakes process crash-loops — it does **not** kill long-running sessions or sub-agents. `ecosystem.config.cjs` is now labelled legacy.
+
+The global `~/.claude/CLAUDE.md` was also corrected: `alvin-bot` was removed from the VPS PM2-process list (it runs locally, not on the VPS) and the cron-hub note now correctly says "als **launchd LaunchAgent**".
+
 ## [4.8.7] — 2026-04-11
 
 ### 🐛 `/update` now detects stale-runtime (rebuild without restart)

package/dist/config.js

@@ -45,7 +45,13 @@ export const config = {
     compactionThreshold: Number(process.env.COMPACTION_THRESHOLD) || 80000,
     // Sub-Agents
     maxSubAgents: Number(process.env.MAX_SUBAGENTS) || 4,
-    subAgentTimeout: Number(process.env.SUBAGENT_TIMEOUT) || 300000, // 5 min
+    // Default sub-agent timeout. -1 / 0 = unlimited (no hard cut-off).
+    // The runtime value lives in sub-agents.json and can be changed at runtime
+    // via /subagents timeout; this constant only seeds the initial config on
+    // first launch when SUBAGENT_TIMEOUT is not set.
+    subAgentTimeout: process.env.SUBAGENT_TIMEOUT !== undefined && process.env.SUBAGENT_TIMEOUT !== ""
+        ? Number(process.env.SUBAGENT_TIMEOUT)
+        : -1,
     // TTS Provider
     ttsProvider: (process.env.TTS_PROVIDER || "edge"),
     elevenlabs: {

package/dist/handlers/commands.js

@@ -1277,9 +1277,29 @@ export function registerCommands(bot) {
                 `Commands: /cron add · delete · toggle · run · info`, { parse_mode: "HTML", reply_markup: keyboard });
             return;
         }
-        // /cron add <schedule> <type> <payload>
+        // /cron add <schedule> <type> <payload> [--timeout <sec|off>]
         if (arg.startsWith("add ")) {
-            const rest = arg.slice(4).trim();
+            let rest = arg.slice(4).trim();
+            // Extract optional --timeout flag from anywhere in the command.
+            // Accepts seconds, "off", "unlimited", "-1", or "0" — anything ≤ 0
+            // or non-numeric collapses to -1 (unlimited).
+            let timeoutMs;
+            const timeoutMatch = rest.match(/(^|\s)--timeout\s+(\S+)/);
+            if (timeoutMatch) {
+                const val = timeoutMatch[2].toLowerCase();
+                if (["off", "unlimited", "infinite", "-1", "0"].includes(val)) {
+                    timeoutMs = -1;
+                }
+                else {
+                    const secs = Number(timeoutMatch[2]);
+                    if (!Number.isFinite(secs) || secs < 0) {
+                        await ctx.reply(`❌ Invalid <code>--timeout</code> value: ${timeoutMatch[2]}`, { parse_mode: "HTML" });
+                        return;
+                    }
+                    timeoutMs = Math.floor(secs * 1000);
+                }
+                rest = rest.replace(/(^|\s)--timeout\s+\S+/, "").trim();
+            }
             // Natural language schedule shortcuts (German + English)
             const naturalSchedules = {
                 "täglich": "0 8 * * *", "daily": "0 8 * * *",
@@ -1342,7 +1362,7 @@ export function registerCommands(bot) {
             else {
                 const sp = rest.indexOf(" ");
                 if (sp < 0) {
-                    await ctx.reply("Format: <code>/cron add &lt;schedule&gt; &lt;type&gt; &lt;payload&gt;</code>\n\nSchedule options:\n• <b>Intervals:</b> 5m, 1h, 30s, 2d\n• <b>Natural:</b> daily, weekly, monthly, weekdays, hourly\n• <b>With time:</b> 8:30 daily, weekdays 9:00\n• <b>German:</b> täglich, wöchentlich, morgens, abends\n• <b>Cron:</b> \"0 9 * * 1-5\"", { parse_mode: "HTML" });
+                    await ctx.reply("Format: <code>/cron add &lt;schedule&gt; &lt;type&gt; &lt;payload&gt; [--timeout &lt;sec|off&gt;]</code>\n\nSchedule options:\n• <b>Intervals:</b> 5m, 1h, 30s, 2d\n• <b>Natural:</b> daily, weekly, monthly, weekdays, hourly\n• <b>With time:</b> 8:30 daily, weekdays 9:00\n• <b>German:</b> täglich, wöchentlich, morgens, abends\n• <b>Cron:</b> \"0 9 * * 1-5\"\n\nOptional <code>--timeout</code> in seconds, or <code>off</code>/<code>-1</code> for unlimited.", { parse_mode: "HTML" });
                     return;
                 }
                 schedule = rest.slice(0, sp);
@@ -1381,12 +1401,19 @@ export function registerCommands(bot) {
                 payload,
                 target: { platform: "telegram", chatId: String(chatId) },
                 createdBy: `telegram:${userId}`,
+                ...(timeoutMs !== undefined ? { timeoutMs } : {}),
             });
             const readableSched = humanReadableSchedule(job.schedule);
+            const timeoutLine = typeof job.timeoutMs === "number"
+                ? job.timeoutMs <= 0
+                    ? `<b>Timeout:</b> ∞ (unlimited)\n`
+                    : `<b>Timeout:</b> ${Math.round(job.timeoutMs / 1000)}s\n`
+                : "";
             await ctx.reply(`✅ <b>Cron Job created</b>\n\n` +
                 `<b>Name:</b> ${job.name}\n` +
                 `📅 <b>${readableSched}</b>\n` +
                 `<b>Type:</b> ${job.type}\n` +
+                timeoutLine +
                 `<b>Next run:</b> ${formatNextRun(job.nextRunAt)}\n` +
                 `<b>ID:</b> <code>${job.id}</code>`, { parse_mode: "HTML" });
             return;
@@ -1734,7 +1761,7 @@ export function registerCommands(bot) {
     // type both "/sub-agents" and "/subagents" — Telegram routes both to this.
     bot.command(["sub_agents", "subagents"], async (ctx) => {
         const lang = getSession(ctx.from.id).language;
-        const { listSubAgents, cancelSubAgent, getSubAgentResult, getMaxParallelAgents, getConfiguredMaxParallel, setMaxParallelAgents, findSubAgentByName, getVisibility, setVisibility, getQueueCap, setQueueCap, } = await import("../services/subagents.js");
+        const { listSubAgents, cancelSubAgent, getSubAgentResult, getMaxParallelAgents, getConfiguredMaxParallel, setMaxParallelAgents, findSubAgentByName, getVisibility, setVisibility, getQueueCap, setQueueCap, getDefaultTimeoutMs, setDefaultTimeoutMs, } = await import("../services/subagents.js");
         const arg = (ctx.match || "").trim();
         const tokens = arg.split(/\s+/).filter(Boolean);
         const sub = tokens[0]?.toLowerCase() || "";
@@ -1792,6 +1819,47 @@ export function registerCommands(bot) {
             await ctx.reply(lines.join("\n"), { parse_mode: "Markdown" });
             return;
         }
+        // /subagents timeout [sec|off|unlimited|-1] — set default sub-agent timeout
+        if (sub === "timeout") {
+            const val = tokens[1];
+            const formatTimeout = (ms) => {
+                if (ms <= 0)
+                    return "∞ (unlimited)";
+                if (ms < 1000)
+                    return `${ms}ms`;
+                const sec = ms / 1000;
+                if (sec < 60)
+                    return `${sec}s`;
+                const min = sec / 60;
+                if (min < 60)
+                    return `${min.toFixed(min < 10 ? 1 : 0)}min`;
+                return `${(min / 60).toFixed(1)}h`;
+            };
+            if (!val) {
+                const current = getDefaultTimeoutMs();
+                await ctx.reply(`⏱ Default sub-agent timeout: *${formatTimeout(current)}*\n\n` +
+                    `Usage: \`/subagents timeout <sec>\` · \`/subagents timeout off\`\n` +
+                    `\`off\`, \`unlimited\`, \`-1\` oder \`0\` = kein Timeout. ` +
+                    `Gilt für neue Subagents und ai-query Cron-Jobs ohne eigenen Wert.`, { parse_mode: "Markdown" });
+                return;
+            }
+            const lower = val.toLowerCase();
+            let ms;
+            if (["off", "unlimited", "infinite", "-1", "0"].includes(lower)) {
+                ms = -1;
+            }
+            else {
+                const secs = Number(val);
+                if (!Number.isFinite(secs) || secs < 0) {
+                    await ctx.reply(`❌ Ungültiger Wert \`${val}\`. Nutze Sekunden (z.B. \`300\`) oder \`off\`.`, { parse_mode: "Markdown" });
+                    return;
+                }
+                ms = Math.floor(secs * 1000);
+            }
+            const effective = setDefaultTimeoutMs(ms);
+            await ctx.reply(`✅ Default sub-agent timeout: *${formatTimeout(effective)}*`, { parse_mode: "Markdown" });
+            return;
+        }
         // /subagents queue <n> — set bounded-queue cap (0 disables queue)
         if (sub === "queue") {
             const n = parseInt(tokens[1] || "", 10);
@@ -1921,6 +1989,10 @@ export function registerCommands(bot) {
             ? `${t("bot.subagents.maxLabel", lang)} 0 ${t("bot.subagents.autoSuffix", lang, { n: effective })}`
             : `${t("bot.subagents.maxLabel", lang)} ${configured}`;
         const visibilityLabel = `${t("bot.subagents.visibilityLabel", lang)} *${getVisibility()}*`;
+        const currentTimeout = getDefaultTimeoutMs();
+        const timeoutLabel = currentTimeout <= 0
+            ? `⏱ Timeout: *∞ (unlimited)*`
+            : `⏱ Timeout: *${Math.round(currentTimeout / 1000)}s*`;
         const agents = listSubAgents();
         let body = "";
         if (agents.length === 0) {
@@ -1931,7 +2003,7 @@ export function registerCommands(bot) {
         }
         const header = t("bot.subagents.header", lang);
         const usage = `\n\n${t("bot.subagents.usage", lang)}`;
-        const full = `${header}\n${maxLabel}\n${visibilityLabel}${body}${usage}`;
+        const full = `${header}\n${maxLabel}\n${visibilityLabel}\n${timeoutLabel}${body}${usage}`;
         await ctx.reply(full, { parse_mode: "Markdown" }).catch(() => ctx.reply(full));
     });
 }

package/dist/i18n.js

@@ -519,10 +519,10 @@ const strings = {
         fr: "Durée : {sec}s · Tokens : {in}/{out}",
     },
     "bot.subagents.usage": {
-        en: "Commands:\n/subagents — show status\n/subagents max <n> — set parallel limit (0=auto)\n/subagents visibility <auto|banner|silent|live> — delivery mode\n/subagents queue <n> — bounded-queue cap (0 = disabled)\n/subagents stats — last 24h run stats\n/subagents list — list all\n/subagents cancel <name|id> — cancel one\n/subagents result <name|id> — show result",
-        de: "Befehle:\n/subagents — Status anzeigen\n/subagents max <n> — Parallel-Limit setzen (0=auto)\n/subagents visibility <auto|banner|silent|live> — Delivery-Modus\n/subagents list — alle anzeigen\n/subagents cancel <name|id> — abbrechen\n/subagents result <name|id> — Ergebnis anzeigen",
-        es: "Comandos:\n/subagents — ver estado\n/subagents max <n> — establecer límite (0=auto)\n/subagents visibility <auto|banner|silent|live> — modo de entrega\n/subagents list — listar todos\n/subagents cancel <nombre|id> — cancelar uno\n/subagents result <nombre|id> — ver resultado",
-        fr: "Commandes :\n/subagents — état\n/subagents max <n> — limite parallèle (0=auto)\n/subagents visibility <auto|banner|silent|live> — mode de livraison\n/subagents list — lister tous\n/subagents cancel <nom|id> — annuler un\n/subagents result <nom|id> — voir résultat",
+        en: "Commands:\n/subagents — show status\n/subagents max <n> — set parallel limit (0=auto)\n/subagents timeout <sec|off> — default timeout (off = unlimited)\n/subagents visibility <auto|banner|silent|live> — delivery mode\n/subagents queue <n> — bounded-queue cap (0 = disabled)\n/subagents stats — last 24h run stats\n/subagents list — list all\n/subagents cancel <name|id> — cancel one\n/subagents result <name|id> — show result",
+        de: "Befehle:\n/subagents — Status anzeigen\n/subagents max <n> — Parallel-Limit setzen (0=auto)\n/subagents timeout <sec|off> — Default-Timeout (off = unendlich)\n/subagents visibility <auto|banner|silent|live> — Delivery-Modus\n/subagents queue <n> — Queue-Cap (0 = deaktiviert)\n/subagents list — alle anzeigen\n/subagents cancel <name|id> — abbrechen\n/subagents result <name|id> — Ergebnis anzeigen",
+        es: "Comandos:\n/subagents — ver estado\n/subagents max <n> — establecer límite (0=auto)\n/subagents timeout <seg|off> — timeout por defecto (off = sin límite)\n/subagents visibility <auto|banner|silent|live> — modo de entrega\n/subagents list — listar todos\n/subagents cancel <nombre|id> — cancelar uno\n/subagents result <nombre|id> — ver resultado",
+        fr: "Commandes :\n/subagents — état\n/subagents max <n> — limite parallèle (0=auto)\n/subagents timeout <sec|off> — délai par défaut (off = illimité)\n/subagents visibility <auto|banner|silent|live> — mode de livraison\n/subagents list — lister tous\n/subagents cancel <nom|id> — annuler un\n/subagents result <nom|id> — voir résultat",
     },
     "bot.subagents.visibilityLabel": {
         en: "Visibility:",

package/dist/index.js

@@ -216,10 +216,20 @@ if (hasTelegram) {
     bot.on("message:photo", handlePhoto);
     bot.on("message:document", handleDocument);
     bot.on("message:text", handleMessage);
-    // Error handling — log but don't crash
+    // Error handling — log but don't crash.
     bot.catch((err) => {
         const ctx = err.ctx;
         const e = err.error;
+        // Telegram's "message is not modified" (400) is harmless — it fires
+        // when a callback handler re-renders an inline keyboard / edited
+        // message with content that happens to match the current message
+        // exactly (e.g. double-tapped toggle button, identical list after
+        // re-render). Swallow it silently so it neither pollutes the logs
+        // nor bubbles up to the user as "internal error".
+        const msg = e instanceof Error ? e.message : String(e);
+        if (/message is not modified/i.test(msg) || /specified new message content.*exactly the same/i.test(msg)) {
+            return;
+        }
         console.error(`Error handling update ${ctx?.update?.update_id}:`, e);
         // Try to notify the user
         if (ctx?.chat?.id) {

package/dist/services/cron.js

@@ -122,11 +122,16 @@ async function executeJob(job) {
             }
             case "shell": {
                 const cmd = job.payload.command || "echo 'no command'";
-                const output = execSync(cmd, {
-                    timeout: 60_000,
+                // Per-job timeout, default = no timeout (execSync treats timeout=0
+                // or "undefined" as infinite). Users opt in via /cron add … --timeout N.
+                const shellOpts = {
                     stdio: "pipe",
                     env: { ...process.env, PATH: process.env.PATH + ":/opt/homebrew/bin:/usr/local/bin" },
-                }).toString().trim();
+                };
+                if (typeof job.timeoutMs === "number" && job.timeoutMs > 0) {
+                    shellOpts.timeout = job.timeoutMs;
+                }
+                const output = execSync(cmd, shellOpts).toString().trim();
                 // Notify with output
                 if (notifyCallback && output) {
                     await notifyCallback(job.target, `🔧 ${job.name}\n\`\`\`\n${output.slice(0, 3000)}\n\`\`\``);
@@ -173,14 +178,20 @@ async function executeJob(job) {
                         ? Number(job.target.chatId)
                         : undefined;
                     const result = await new Promise((resolve, reject) => {
-                        spawnSubAgent({
+                        // Only pass `timeout` through when the job has a per-job value.
+                        // Otherwise the sub-agent inherits the current /subagents default.
+                        const spawnConfig = {
                             name: job.name,
                             prompt,
                             workingDir: BOT_ROOT,
                             source: "cron",
                             parentChatId,
                             onComplete: (r) => resolve(r),
-                        }).catch(reject);
+                        };
+                        if (typeof job.timeoutMs === "number") {
+                            spawnConfig.timeout = job.timeoutMs;
+                        }
+                        spawnSubAgent(spawnConfig).catch(reject);
                     });
                     // Non-success: don't notify here. The I3 delivery router has
                     // already posted the appropriate banner (cancelled / timeout /
@@ -309,6 +320,7 @@ export function createJob(input) {
         nextRunAt: null,
         runCount: 0,
         createdBy: input.createdBy || "unknown",
+        ...(typeof input.timeoutMs === "number" ? { timeoutMs: input.timeoutMs } : {}),
     };
     // Calculate first run
     job.nextRunAt = calculateNextRun(job);

package/dist/services/subagents.js

@@ -21,6 +21,14 @@ let configCache = null;
 function isValidVisibility(v) {
     return v === "auto" || v === "banner" || v === "silent" || v === "live";
 }
+/** Resolve the initial default timeout from config.ts, which itself seeds
+ *  from the SUBAGENT_TIMEOUT env var. -1 = unlimited. */
+function seedDefaultTimeout() {
+    const raw = config.subAgentTimeout;
+    if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0)
+        return -1;
+    return Math.floor(raw);
+}
 function loadSubAgentsConfig() {
     if (configCache)
         return configCache;
@@ -33,14 +41,18 @@ function loadSubAgentsConfig() {
             queueCap: typeof parsed.queueCap === "number"
                 ? Math.max(0, Math.min(Math.floor(parsed.queueCap), ABSOLUTE_MAX_QUEUE))
                 : DEFAULT_QUEUE_CAP,
+            defaultTimeoutMs: typeof parsed.defaultTimeoutMs === "number" && Number.isFinite(parsed.defaultTimeoutMs)
+                ? (parsed.defaultTimeoutMs <= 0 ? -1 : Math.floor(parsed.defaultTimeoutMs))
+                : seedDefaultTimeout(),
         };
     }
     catch {
-        // File missing or invalid — seed from env var then default to auto
+        // File missing or invalid — seed from env vars then default to auto/unlimited
         configCache = {
             maxParallel: Number(process.env.MAX_SUBAGENTS) || 0,
             visibility: "auto",
             queueCap: DEFAULT_QUEUE_CAP,
+            defaultTimeoutMs: seedDefaultTimeout(),
         };
     }
     return configCache;
@@ -102,6 +114,18 @@ export function setQueueCap(n) {
     saveSubAgentsConfig({ ...cfg, queueCap: clamped });
     return clamped;
 }
+/** Current default timeout in ms. -1 = unlimited. */
+export function getDefaultTimeoutMs() {
+    return loadSubAgentsConfig().defaultTimeoutMs;
+}
+/** Set the default timeout in ms. Any value ≤ 0 or non-finite collapses
+ *  to -1 (unlimited). Returns the persisted value. */
+export function setDefaultTimeoutMs(ms) {
+    const normalized = !Number.isFinite(ms) || ms <= 0 ? -1 : Math.floor(ms);
+    const cfg = loadSubAgentsConfig();
+    saveSubAgentsConfig({ ...cfg, defaultTimeoutMs: normalized });
+    return normalized;
+}
 // ── State ───────────────────────────────────────────────
 const activeAgents = new Map();
 // ── Name resolver (B2) ──────────────────────────────────
@@ -433,14 +457,23 @@ export function spawnSubAgent(agentConfig) {
     const resolved = resolveAgentName(agentConfig.name);
     const resolvedName = resolved.name;
     const id = crypto.randomUUID();
-    const timeout = agentConfig.timeout ?? config.subAgentTimeout;
+    // Timeout resolution order:
+    //   1. Per-spawn override (agentConfig.timeout) — used by cron jobs that
+    //      carry their own timeoutMs.
+    //   2. Runtime default from sub-agents.json (set via /subagents timeout).
+    //   3. config.subAgentTimeout fallback (seeded from SUBAGENT_TIMEOUT env).
+    // Any value ≤ 0 means "no timeout" — we simply don't arm the abort timer.
+    // The existing null-safe `clearTimeout(timeoutId)` call sites make this
+    // a safe no-op when the agent finishes or is cancelled.
+    const timeout = agentConfig.timeout ?? getDefaultTimeoutMs();
     const abort = new AbortController();
-    const timeoutId = setTimeout(() => abort.abort(), timeout);
+    const timeoutId = timeout > 0 ? setTimeout(() => abort.abort(), timeout) : null;
     const willRunImmediately = running < maxParallel;
     const canQueue = !willRunImmediately && queueCap > 0 && queuedLen < queueCap;
     if (!willRunImmediately && !canQueue) {
         // No slot, no queue room → priority-aware reject
-        clearTimeout(timeoutId);
+        if (timeoutId)
+            clearTimeout(timeoutId);
         const source = sourceOf(agentConfig);
         const runningAgents = [...activeAgents.values()].filter((a) => a.info.status === "running");
         const userSlots = runningAgents.filter((a) => a.info.source === "user").length;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alvin-bot",
-  "version": "4.8.7",
+  "version": "4.8.8",
   "description": "Alvin Bot — Your personal AI agent on Telegram, WhatsApp, Discord, Signal, and Web.",
   "type": "module",
   "main": "dist/index.js",