alvin-bot 4.5.0 → 4.6.0

package/dist/handlers/commands.js

@@ -20,6 +20,15 @@ import { storePassword, revokePassword, getSudoStatus, verifyPassword } from "..
 import { config } from "../config.js";
 import { getWebPort } from "../web/server.js";
 import { getUsageSummary, getAllRateLimits, formatTokens } from "../services/usage-tracker.js";
+import { runUpdate, getAutoUpdate, setAutoUpdate, startAutoUpdateLoop } from "../services/updater.js";
+import { getHealthStatus, isFailedOver } from "../services/heartbeat.js";
+import { t, LOCALE_NAMES, LOCALE_FLAGS } from "../i18n.js";
+// Kick off auto-update loop on module load if the persistent flag is set.
+// Doing this as a module side-effect avoids touching the bot entry point.
+if (getAutoUpdate()) {
+    // 30s delay so the bot is fully started before the first check
+    setTimeout(() => startAutoUpdateLoop(), 30_000);
+}
 /** Bot start time for uptime tracking */
 const botStartTime = Date.now();
 /** Format bytes to human-readable */
@@ -32,6 +41,44 @@ function formatBytes(bytes) {
         return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
     return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
 }
+/** Render a working directory path with a meaningful label.
+ * Home → 🏠 ~ (Home), anywhere under home → 📁 ~/rel/path, absolute → 📁 /path */
+function formatWorkingDir(workingDir, locale) {
+    const home = os.homedir();
+    if (workingDir === home) {
+        return `🏠 \`~\` _(${t("bot.status.homeLabel", locale)})_`;
+    }
+    if (workingDir.startsWith(home + "/")) {
+        return `📁 \`~${workingDir.slice(home.length)}\``;
+    }
+    return `📁 \`${workingDir}\``;
+}
+/** Format a raw token count for the context progress line.
+ * Keeps precision tight — "450k/1M" not "450.2k/1.0M". */
+function formatContextTokens(n) {
+    if (n < 1_000)
+        return String(n);
+    if (n < 1_000_000)
+        return `${Math.round(n / 1_000)}k`;
+    const m = n / 1_000_000;
+    return m >= 10 ? `${Math.round(m)}M` : `${m.toFixed(1)}M`;
+}
+/** Human relative-time rendered in the user's locale. */
+function formatRelativeTime(ms, locale) {
+    const s = Math.floor(ms / 1000);
+    if (s < 10)
+        return t("bot.time.justNow", locale);
+    if (s < 60)
+        return t("bot.time.secondsAgo", locale, { n: s });
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return t("bot.time.minutesAgo", locale, { n: m });
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return t("bot.time.hoursAgo", locale, { n: h });
+    const d = Math.floor(h / 24);
+    return t(d === 1 ? "bot.time.dayAgo" : "bot.time.daysAgo", locale, { n: d });
+}
 const EFFORT_LABELS = {
     low: "Low — Quick, concise answers",
     medium: "Medium — Moderate reasoning depth",
@@ -80,6 +127,10 @@ export function registerCommands(bot) {
             `/status — Current status\n` +
             `/new — Start new session\n` +
             `/cancel — Cancel running request\n\n` +
+            `🔧 *Ops*\n` +
+            `/restart — Restart the bot\n` +
+            `/update — Pull latest + rebuild + restart\n` +
+            `/autoupdate on|off — Auto-update loop (6h)\n\n` +
             `_Tip: Send me documents, photos, or voice messages!_\n` +
             `_In groups: @mention me or reply to my messages._`, { parse_mode: "Markdown" });
     });
@@ -99,9 +150,13 @@ export function registerCommands(bot) {
         { command: "recall", description: "Semantic memory search" },
         { command: "remember", description: "Remember something" },
         { command: "cron", description: "Manage scheduled jobs" },
+        { command: "subagents", description: "Manage background sub-agents" },
         { command: "webui", description: "Open Web UI in browser" },
         { command: "setup", description: "Configure API keys & platforms" },
         { command: "cancel", description: "Cancel running request" },
+        { command: "restart", description: "Restart the bot (PM2)" },
+        { command: "update", description: "Pull latest, build, restart" },
+        { command: "autoupdate", description: "Auto-update on|off|status" },
     ]).catch(err => console.error("Failed to set bot commands:", err));
     bot.command("start", async (ctx) => {
         const registry = getRegistry();
@@ -167,6 +222,7 @@ export function registerCommands(bot) {
     bot.command("status", async (ctx) => {
         const userId = ctx.from.id;
         const session = getSession(userId);
+        const lang = session.language;
         const registry = getRegistry();
         const active = registry.getActive();
         const info = active.getInfo();
@@ -174,28 +230,75 @@ export function registerCommands(bot) {
         const uptimeMs = Date.now() - botStartTime;
         const uptimeH = Math.floor(uptimeMs / 3_600_000);
         const uptimeM = Math.floor((uptimeMs % 3_600_000) / 60_000);
-        // Session duration
-        const sessionMs = Date.now() - session.startedAt;
-        const sessionM = Math.floor(sessionMs / 60_000);
         // Provider type detection
         const isOAuth = active.config.type === "claude-sdk" || active.config.type === "codex-cli";
-        const providerTag = isOAuth ? "OAuth/Flat-Rate" : "API";
-        // Token stats
-        const inTok = formatTokens(session.totalInputTokens);
-        const outTok = formatTokens(session.totalOutputTokens);
-        // Cost display
-        const costStr = isOAuth
-            ? `$0.00 (Flat-Rate) | ${formatTokens(session.totalInputTokens + session.totalOutputTokens)} tokens`
-            : `$${session.totalCost.toFixed(4)}`;
-        // Provider breakdown (session)
-        let providerLines = "";
-        const providers = Object.entries(session.queriesByProvider);
-        if (providers.length > 0) {
-            providerLines = providers.map(([key, queries]) => {
-                const cost = session.costByProvider[key] || 0;
-                const costLabel = isOAuth && key === registry.getActiveKey() ? "flat" : `$${cost.toFixed(4)}`;
-                return `  ${key}: ${queries}q, ${costLabel}`;
-            }).join("\n");
+        const providerTag = isOAuth ? "_Flat-Rate_" : "_API_";
+        // ── Session block — intelligent empty/active/idle rendering ─────────
+        // The in-memory session is always fresh after a bot restart, so plain
+        // "Session (0 min)" with all zeros looks broken. Render an empty state
+        // explicitly, plus active/idle badges based on last activity.
+        const now = Date.now();
+        const idleMs = now - session.lastActivity;
+        const sessionAgeMs = now - session.startedAt;
+        const sessionAgeMin = Math.floor(sessionAgeMs / 60_000);
+        const IDLE_THRESHOLD_MS = 2 * 60 * 1000;
+        const isEmpty = session.messageCount === 0
+            && !session.sessionId
+            && session.history.length === 0;
+        let sessionBlock;
+        const sessionHeader = t("bot.status.sessionHeader", lang);
+        if (isEmpty) {
+            sessionBlock = `${sessionHeader}\n${t("bot.status.sessionNew", lang)}`;
+        }
+        else {
+            const isActiveNow = idleMs < IDLE_THRESHOLD_MS;
+            const badge = isActiveNow ? t("bot.status.active", lang) : t("bot.status.idle", lang);
+            // Line 1: activity summary
+            const msgWord = t(session.messageCount === 1 ? "bot.status.message" : "bot.status.messages", lang);
+            const toolWord = t(session.toolUseCount === 1 ? "bot.status.toolCall" : "bot.status.toolCalls", lang);
+            const summary = `${badge} — ${session.messageCount} ${msgWord}, ${session.toolUseCount} ${toolWord}`;
+            // Line 2: tokens (only if non-zero — zero is noise after restart)
+            const totalTok = session.totalInputTokens + session.totalOutputTokens;
+            const tokenLine = totalTok > 0
+                ? `\nTokens: ${formatTokens(session.totalInputTokens)} in / ${formatTokens(session.totalOutputTokens)} out`
+                : "";
+            // Line 2.5: context window usage progress (X / Y with percentage).
+            // Shown only when we have both a last-turn input token count AND the
+            // provider declares its context window. Otherwise skipped to avoid
+            // showing meaningless zeros.
+            const ctxWindow = active.config.contextWindow;
+            let contextLine = "";
+            if (session.lastTurnInputTokens > 0 && typeof ctxWindow === "number" && ctxWindow > 0) {
+                const used = session.lastTurnInputTokens;
+                const pct = Math.round((used / ctxWindow) * 100);
+                contextLine = `\nContext: ${formatContextTokens(used)}/${formatContextTokens(ctxWindow)} (${pct}%)`;
+            }
+            // Line 3: timing (age + last turn)
+            const ageStr = sessionAgeMin >= 1
+                ? `${sessionAgeMin} min`
+                : t("bot.status.lessThanMin", lang);
+            const timingLine = `\n${t("bot.status.duration", lang)}: ${ageStr} | ${t("bot.status.lastTurn", lang)}: ${formatRelativeTime(idleMs, lang)}`;
+            // Line 4: cost (only for non-OAuth providers AND only when meaningful)
+            const costLine = (!isOAuth && session.totalCost > 0)
+                ? `\nCost: $${session.totalCost.toFixed(4)}`
+                : "";
+            // Line 5: telemetry counters — compactions (non-SDK), checkpoint
+            // hints (SDK), and SDK-internal sub-tasks (Claude's Task tool).
+            // Each only shown when > 0 to keep the status clean.
+            const telemetryParts = [];
+            if (session.compactionCount > 0) {
+                telemetryParts.push(`Compactions: ${session.compactionCount}`);
+            }
+            if (session.checkpointHintsInjected > 0) {
+                telemetryParts.push(`Checkpoint hints: ${session.checkpointHintsInjected}`);
+            }
+            if (session.sdkSubTaskCount > 0) {
+                telemetryParts.push(`SDK sub-tasks: ${session.sdkSubTaskCount}`);
+            }
+            const telemetryLine = telemetryParts.length > 0
+                ? `\n${telemetryParts.join(" | ")}`
+                : "";
+            sessionBlock = `${sessionHeader}\n${summary}${tokenLine}${contextLine}${timingLine}${costLine}${telemetryLine}`;
         }
         // Usage summary (daily/weekly from tracker)
         const usage = getUsageSummary();
@@ -234,20 +337,52 @@ export function registerCommands(bot) {
         const memStats = getMemoryStats();
         const idxStats = getIndexStats();
         const memLine = `${memStats.dailyLogs} days, ${memStats.todayEntries} entries today, ${formatBytes(memStats.longTermSize)} LTM | 🔍 ${idxStats.entries} vectors`;
+        // Provider health + failover state
+        const healthRows = getHealthStatus();
+        const failedOver = isFailedOver();
+        const activeKey = registry.getActiveKey();
+        let healthLines = "";
+        if (healthRows.length > 0) {
+            // Render each row, live-checking lifecycle-managed providers so the
+            // status reflects reality (not just heartbeat's always-healthy flag
+            // for on-demand runners).
+            const rows = await Promise.all(healthRows.map(async (h) => {
+                const isActive = h.key === activeKey;
+                const arrow = isActive ? "→" : "  ";
+                const provider = registry.get(h.key);
+                // Lifecycle-managed providers (local runners) get on-demand rendering
+                if (provider?.lifecycle) {
+                    const running = await provider.lifecycle.isRunning();
+                    const botManaged = provider.lifecycle.isBotManaged();
+                    if (!running) {
+                        return `${arrow} 💤 ${h.key} ${t("bot.status.ollamaOnDemand", lang)}`;
+                    }
+                    if (botManaged) {
+                        return `${arrow} 🔧 ${h.key} ${t("bot.status.ollamaBotManaged", lang)}`;
+                    }
+                    return `${arrow} ✅ ${h.key} ${t("bot.status.ollamaExternal", lang)}`;
+                }
+                // Default rendering for cloud providers
+                const icon = h.healthy ? "✅" : "❌";
+                const latency = h.latencyMs > 0 ? ` ${h.latencyMs}ms` : "";
+                const fails = h.failCount > 0 ? ` (${h.failCount} fails)` : "";
+                return `${arrow} ${icon} ${h.key}${latency}${fails}`;
+            }));
+            const failoverBadge = failedOver ? ` ${t("bot.status.failedOver", lang)}` : "";
+            healthLines = `\n${t("bot.status.providerHealth", lang)}${failoverBadge}\n${rows.join("\n")}\n`;
+        }
         await ctx.reply(`🤖 *Alvin Bot Status*\n\n` +
-            `*Model:* ${info.name} — ${providerTag}\n` +
+            `*Model:* ${info.name} ${providerTag}\n` +
             `*Effort:* ${EFFORT_LABELS[session.effort]}\n` +
-            `*Voice:* ${session.voiceReply ? "on" : "off"} | *Dir:* \`${session.workingDir.replace(os.homedir(), "~")}\`\n\n` +
-            `📊 *Session* (${sessionM} min)\n` +
-            `Messages: ${session.messageCount} | Tools: ${session.toolUseCount}\n` +
-            `Tokens: ${inTok} in / ${outTok} out\n` +
-            `Cost: ${costStr}\n` +
-            (providerLines ? `${providerLines}\n` : "") +
+            `*Voice:* ${session.voiceReply ? "on" : "off"}\n` +
+            `*Working Dir:* ${formatWorkingDir(session.workingDir, lang)}\n\n` +
+            `${sessionBlock}\n` +
             `\n📈 *Usage*\n` +
-            `Today: ${usage.today.queries}q, ${todayTok} tokens${todayCostStr}\n` +
-            `Week:  ${usage.week.queries}q, ${weekTok} tokens${weekCostStr}\n` +
-            (usage.daysTracked > 1 ? `Avg:   ${formatTokens(usage.avgDailyTokens)} tok/day\n` : "") +
+            `Today: ${usage.today.queries} req, ${todayTok} tokens${todayCostStr}\n` +
+            `Week:  ${usage.week.queries} req, ${weekTok} tokens${weekCostStr}\n` +
+            (usage.daysTracked > 1 ? `Avg:   ${formatTokens(usage.avgDailyTokens)} tok/day _(7d rolling)_\n` : "") +
             rlLines +
+            healthLines +
             `\n🧠 *Memory:* ${memLine}\n` +
             `⏱ *Uptime:* ${uptimeH}h ${uptimeM}m`, { parse_mode: "Markdown" });
     });
@@ -297,7 +432,39 @@ export function registerCommands(bot) {
         await ctx.editMessageText(`🧠 *Choose reasoning depth:*\n\nActive: *${EFFORT_LABELS[session.effort]}*`, { parse_mode: "Markdown", reply_markup: keyboard });
         await ctx.answerCallbackQuery(`Effort: ${EFFORT_LABELS[session.effort]}`);
     });
+    // Helper: switch provider with lifecycle management for local runners.
+    // Boots the target's lifecycle daemon (if any) BEFORE the switch, and
+    // tears down the previous provider's lifecycle (if any) AFTER the switch.
+    // Fully generic — no hardcoded provider keys.
+    async function switchProviderWithLifecycle(targetKey, lang) {
+        const registry = getRegistry();
+        const previousKey = registry.getActiveKey();
+        if (previousKey === targetKey)
+            return { ok: true };
+        const target = registry.get(targetKey);
+        if (!target)
+            return { ok: false, error: `provider "${targetKey}" not found` };
+        const previous = registry.get(previousKey);
+        // Boot the target's lifecycle (if any) before the switch
+        if (target.lifecycle) {
+            const booted = await target.lifecycle.ensureRunning();
+            if (!booted) {
+                return { ok: false, error: t("bot.model.bootFailed", lang, { key: targetKey }) };
+            }
+        }
+        if (!registry.switchTo(targetKey)) {
+            return { ok: false, error: "switch rejected by registry" };
+        }
+        // Tear down the previous provider's lifecycle (if any) after the switch.
+        // ensureStopped() internally checks isBotManaged — no-op for externally
+        // managed daemons.
+        if (previous?.lifecycle) {
+            await previous.lifecycle.ensureStopped();
+        }
+        return { ok: true };
+    }
     bot.command("model", async (ctx) => {
+        const lang = getSession(ctx.from.id).language;
         const arg = ctx.match?.trim().toLowerCase();
         const registry = getRegistry();
         if (!arg) {
@@ -308,23 +475,25 @@ export function registerCommands(bot) {
                 const label = p.active ? `✅ ${p.name}` : p.name;
                 keyboard.text(label, `model:${p.key}`).row();
             }
-            await ctx.reply(`🤖 *Choose model:*\n\nActive: *${registry.getActive().getInfo().name}*`, { parse_mode: "Markdown", reply_markup: keyboard });
+            await ctx.reply(`${t("bot.model.chooseHeader", lang)}\n\n${t("bot.model.active", lang)} *${registry.getActive().getInfo().name}*`, { parse_mode: "Markdown", reply_markup: keyboard });
             return;
         }
-        if (registry.switchTo(arg)) {
-            const provider = registry.get(arg);
-            const info = provider.getInfo();
-            await ctx.reply(`✅ Switched model: ${info.name} (${info.model})`);
+        const result = await switchProviderWithLifecycle(arg, lang);
+        if (result.ok) {
+            const info = registry.get(arg).getInfo();
+            await ctx.reply(`${t("bot.model.switched", lang)} ${info.name} (${info.model})`);
         }
         else {
-            await ctx.reply(`Model "${arg}" not found. Use /model to see all options.`);
+            await ctx.reply(`${t("bot.model.switchFailed", lang)} ${result.error || `"${arg}"`}\n${t("bot.model.notFoundHint", lang)}`);
         }
     });
     // Inline keyboard callback for model switching
     bot.callbackQuery(/^model:(.+)$/, async (ctx) => {
         const key = ctx.match[1];
         const registry = getRegistry();
-        if (registry.switchTo(key)) {
+        const lang = getSession(ctx.from.id).language;
+        const result = await switchProviderWithLifecycle(key, lang);
+        if (result.ok) {
             const provider = registry.get(key);
             const info = provider.getInfo();
             // Update the keyboard to show new selection
@@ -338,7 +507,7 @@ export function registerCommands(bot) {
             await ctx.answerCallbackQuery(`Switched: ${info.name}`);
         }
         else {
-            await ctx.answerCallbackQuery(`Model "${key}" not found`);
+            await ctx.answerCallbackQuery(`Switch failed: ${result.error || "unknown"}`);
         }
     });
     // ── Fallback Order ────────────────────────────────────────────────────
@@ -616,60 +785,71 @@ export function registerCommands(bot) {
             caption: `📄 Export: ${session.history.length} messages`,
         });
     });
+    // Helper: build the /language inline keyboard for all 4 locales + auto.
+    function buildLangKeyboard(current) {
+        const kb = new InlineKeyboard();
+        const order = ["en", "de", "es", "fr"];
+        // First row: 2 buttons
+        kb.text(`${current === "en" ? "✅ " : ""}${LOCALE_FLAGS.en} ${LOCALE_NAMES.en}`, "lang:en").text(`${current === "de" ? "✅ " : ""}${LOCALE_FLAGS.de} ${LOCALE_NAMES.de}`, "lang:de").row();
+        // Second row: 2 buttons
+        kb.text(`${current === "es" ? "✅ " : ""}${LOCALE_FLAGS.es} ${LOCALE_NAMES.es}`, "lang:es").text(`${current === "fr" ? "✅ " : ""}${LOCALE_FLAGS.fr} ${LOCALE_NAMES.fr}`, "lang:fr").row();
+        // Third row: auto-detect
+        void order; // silence unused warning from the `order` declaration (kept for doc clarity)
+        kb.text(t("bot.lang.autoDetect", current), "lang:auto");
+        return kb;
+    }
     bot.command("lang", async (ctx) => {
         const userId = ctx.from.id;
         const session = getSession(userId);
         const arg = ctx.match?.trim().toLowerCase();
         if (!arg) {
-            const keyboard = new InlineKeyboard()
-                .text(session.language === "de" ? "✅ Deutsch" : "Deutsch", "lang:de")
-                .text(session.language === "en" ? "✅ English" : "English", "lang:en")
-                .row()
-                .text("🔄 Auto-detect", "lang:auto");
-            await ctx.reply(`🌐 *Language:* ${session.language === "de" ? "Deutsch" : "English"}`, {
+            const header = t("bot.lang.header", session.language);
+            const currentName = `${LOCALE_FLAGS[session.language]} ${LOCALE_NAMES[session.language]}`;
+            await ctx.reply(`${header} ${currentName}`, {
                 parse_mode: "Markdown",
-                reply_markup: keyboard,
+                reply_markup: buildLangKeyboard(session.language),
             });
             return;
         }
         if (arg === "auto") {
             const { resetToAutoLanguage } = await import("../services/language-detect.js");
             resetToAutoLanguage(userId);
-            await ctx.reply("🔄 Auto-detection enabled. I'll adapt to the language you write in.");
+            await ctx.reply(t("bot.lang.autoEnabled", session.language));
         }
-        else if (arg === "de" || arg === "en") {
+        else if (arg === "en" || arg === "de" || arg === "es" || arg === "fr") {
             session.language = arg;
             const { setExplicitLanguage } = await import("../services/language-detect.js");
             setExplicitLanguage(userId, arg);
-            await ctx.reply(arg === "de" ? "✅ Language: Deutsch (fixed)" : "✅ Language: English (fixed)");
+            await ctx.reply(t("bot.lang.setFixed", arg, { name: LOCALE_NAMES[arg] }));
         }
         else {
-            await ctx.reply("Use: `/lang de`, `/lang en`, or `/lang auto`", { parse_mode: "Markdown" });
+            await ctx.reply(t("bot.lang.usage", session.language), { parse_mode: "Markdown" });
         }
     });
-    bot.callbackQuery(/^lang:(de|en|auto)$/, async (ctx) => {
+    // /lang callback — accept all 4 locales plus auto
+    bot.callbackQuery(/^lang:(en|de|es|fr|auto)$/, async (ctx) => {
         const choice = ctx.match[1];
         const userId = ctx.from.id;
         const session = getSession(userId);
         if (choice === "auto") {
             const { resetToAutoLanguage } = await import("../services/language-detect.js");
             resetToAutoLanguage(userId);
-            await ctx.answerCallbackQuery({ text: "🔄 Auto-detect enabled" });
-            await ctx.editMessageText("🌐 *Language:* Auto-detect 🔄", { parse_mode: "Markdown" });
+            await ctx.answerCallbackQuery({ text: t("bot.lang.autoEnabled", session.language).slice(0, 60) });
+            await ctx.editMessageText(`${t("bot.lang.header", session.language)} ${t("bot.lang.autoDetect", session.language)}`, {
+                parse_mode: "Markdown",
+            });
             return;
         }
-        const lang = choice;
-        session.language = lang;
+        const newLang = choice;
+        session.language = newLang;
         const { setExplicitLanguage } = await import("../services/language-detect.js");
-        setExplicitLanguage(userId, lang);
-        const keyboard = new InlineKeyboard()
-            .text(lang === "de" ? "✅ Deutsch" : "Deutsch", "lang:de")
-            .text(lang === "en" ? "✅ English" : "English", "lang:en");
-        await ctx.editMessageText(`🌐 *Language:* ${lang === "de" ? "Deutsch" : "English"}`, {
+        setExplicitLanguage(userId, newLang);
+        const currentName = `${LOCALE_FLAGS[newLang]} ${LOCALE_NAMES[newLang]}`;
+        await ctx.editMessageText(`${t("bot.lang.header", newLang)} ${currentName}`, {
             parse_mode: "Markdown",
-            reply_markup: keyboard,
+            reply_markup: buildLangKeyboard(newLang),
         });
-        await ctx.answerCallbackQuery(lang === "de" ? "Deutsch" : "English");
+        await ctx.answerCallbackQuery(LOCALE_NAMES[newLang]);
     });
     bot.command("memory", async (ctx) => {
         const stats = getMemoryStats();
@@ -1478,12 +1658,230 @@ export function registerCommands(bot) {
     bot.command("cancel", async (ctx) => {
         const userId = ctx.from.id;
         const session = getSession(userId);
+        const lang = session.language;
         if (session.isProcessing && session.abortController) {
             session.abortController.abort();
-            await ctx.reply("Cancelling request...");
+            await ctx.reply(t("bot.cancel.cancelling", lang));
+        }
+        else {
+            await ctx.reply(t("bot.cancel.noRunning", lang));
+        }
+    });
+    // /restart — trigger a PM2-managed restart by exiting the process.
+    // The PM2 supervisor picks up the exit and respawns with --update-env.
+    bot.command("restart", async (ctx) => {
+        const lang = getSession(ctx.from.id).language;
+        await ctx.reply(t("bot.restart.triggered", lang));
+        // Small delay so the Telegram message is actually delivered before exit
+        setTimeout(() => process.exit(0), 500);
+    });
+    // /update — git pull + install + build, then PM2-restart if anything changed.
+    bot.command("update", async (ctx) => {
+        const lang = getSession(ctx.from.id).language;
+        await ctx.reply(t("bot.update.checking", lang));
+        try {
+            const result = await runUpdate();
+            if (result.ok) {
+                await ctx.reply(`✅ ${result.message}`);
+                if (result.requiresRestart) {
+                    await ctx.reply(t("bot.update.restarting", lang));
+                    setTimeout(() => process.exit(0), 500);
+                }
+            }
+            else {
+                await ctx.reply(`${t("bot.update.failed", lang)}\n\`${result.message}\``, { parse_mode: "Markdown" });
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            await ctx.reply(`${t("bot.update.error", lang)} ${msg}`);
+        }
+    });
+    // /autoupdate on|off|status — toggle the background auto-update loop.
+    // Persisted to ~/.alvin-bot/auto-update.flag so it survives restarts.
+    bot.command("autoupdate", async (ctx) => {
+        const lang = getSession(ctx.from.id).language;
+        const arg = (ctx.match || "").trim().toLowerCase();
+        if (arg === "on") {
+            setAutoUpdate(true);
+            await ctx.reply(t("bot.autoupdate.enabled", lang), { parse_mode: "Markdown" });
+        }
+        else if (arg === "off") {
+            setAutoUpdate(false);
+            await ctx.reply(t("bot.autoupdate.disabled", lang), { parse_mode: "Markdown" });
+        }
+        else {
+            const status = getAutoUpdate();
+            await ctx.reply(`${t("bot.autoupdate.statusLabel", lang)} *${status ? "ON" : "OFF"}*\n\n${t("bot.autoupdate.commandsLabel", lang)}\n\`/autoupdate on\`\n\`/autoupdate off\``, { parse_mode: "Markdown" });
+        }
+    });
+    // ── /sub-agents — manage background subagents (cron jobs + manual spawns) ──
+    //
+    // /sub-agents                → show current config + running agents
+    // /sub-agents max <n>        → set max parallel (0 = auto = CPU cores, capped 16)
+    // /sub-agents list           → list all agents with IDs
+    // /sub-agents cancel <id>    → cancel a specific running agent
+    // /sub-agents result <id>    → show the result of a completed agent
+    //
+    // Grammy normalises command names — dashes are not allowed in the command
+    // string, so the actual handler binds to "subagents" (no dash). Users can
+    // 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, } = await import("../services/subagents.js");
+        const arg = (ctx.match || "").trim();
+        const tokens = arg.split(/\s+/).filter(Boolean);
+        const sub = tokens[0]?.toLowerCase() || "";
+        // Helper: shorten a UUID to its first 8 chars for display
+        const shortId = (id) => id.slice(0, 8);
+        // Helper: format a SubAgentInfo line with depth indent (F2 visibility)
+        const formatAgent = (a) => {
+            const indent = "  ".repeat(Math.max(0, a.depth));
+            const ageSec = Math.floor((Date.now() - a.startedAt) / 1000);
+            const ageLabel = ageSec < 60 ? `${ageSec}s` : ageSec < 3600 ? `${Math.floor(ageSec / 60)}m` : `${Math.floor(ageSec / 3600)}h`;
+            const sourceBadge = a.source === "cron" ? "⏰" : a.source === "implicit" ? "🔗" : "👤";
+            const depthTag = a.depth > 0 ? ` d${a.depth}` : "";
+            return `${indent}${sourceBadge} \`${shortId(a.id)}\` ${a.name} (${a.status}, ${ageLabel}${depthTag})`;
+        };
+        // /sub-agents max <n>
+        if (sub === "max") {
+            const n = parseInt(tokens[1] || "", 10);
+            if (isNaN(n)) {
+                await ctx.reply(t("bot.subagents.usage", lang), { parse_mode: "Markdown" });
+                return;
+            }
+            const effective = setMaxParallelAgents(n);
+            await ctx.reply(t("bot.subagents.maxSet", lang, { n, eff: effective }), { parse_mode: "Markdown" });
+            return;
+        }
+        // /sub-agents visibility <auto|banner|silent>
+        if (sub === "visibility") {
+            const mode = tokens[1];
+            if (!mode) {
+                // Show current value
+                const current = getVisibility();
+                await ctx.reply(`${t("bot.subagents.visibilityLabel", lang)} *${current}*\n\n${t("bot.subagents.usage", lang)}`, { parse_mode: "Markdown" });
+                return;
+            }
+            try {
+                setVisibility(mode);
+                await ctx.reply(t("bot.subagents.visibilitySet", lang, { mode }), { parse_mode: "Markdown" });
+            }
+            catch {
+                await ctx.reply(t("bot.subagents.visibilityInvalid", lang, { mode }), { parse_mode: "Markdown" });
+            }
+            return;
+        }
+        // /sub-agents list  — same rendering as the default, but forced
+        if (sub === "list") {
+            const agents = listSubAgents();
+            if (agents.length === 0) {
+                await ctx.reply(t("bot.subagents.noneRunning", lang));
+                return;
+            }
+            const lines = agents.map(formatAgent).join("\n");
+            await ctx.reply(`${t("bot.subagents.activeHeader", lang)}\n${lines}`, { parse_mode: "Markdown" });
+            return;
+        }
+        // /sub-agents cancel <name|id>
+        // Resolution order: exact name → base-name (single match) → UUID prefix.
+        // If the base name is ambiguous, show a disambiguation reply.
+        if (sub === "cancel") {
+            const key = tokens[1] || "";
+            if (!key) {
+                await ctx.reply(t("bot.subagents.usage", lang), { parse_mode: "Markdown" });
+                return;
+            }
+            // 1. Ambiguity check via the resolver
+            const ambig = findSubAgentByName(key, { ambiguousAsList: true });
+            if (ambig && "ambiguous" in ambig) {
+                const list = ambig.candidates.map((c) => `• ${c.name}`).join("\n");
+                await ctx.reply(`Mehrdeutig — welchen meinst du?\n${list}\n\nBenutze den genauen Namen (z.B. \`${ambig.candidates[0].name}\`).`, { parse_mode: "Markdown" });
+                return;
+            }
+            // 2. Name match → cancel via that id
+            let targetId = null;
+            let displayName = key;
+            if (ambig && !("ambiguous" in ambig)) {
+                targetId = ambig.id;
+                displayName = ambig.name;
+            }
+            else {
+                // 3. Fallback: UUID-prefix match (back-compat with old usage)
+                const allAgents = listSubAgents();
+                const byId = allAgents.find((a) => a.id.startsWith(key));
+                if (byId) {
+                    targetId = byId.id;
+                    displayName = byId.name;
+                }
+            }
+            if (!targetId || !cancelSubAgent(targetId)) {
+                await ctx.reply(t("bot.subagents.notFound", lang, { id: key }));
+                return;
+            }
+            await ctx.reply(t("bot.subagents.cancelled", lang, { id: displayName }));
+            return;
+        }
+        // /sub-agents result <name|id>
+        if (sub === "result") {
+            const key = tokens[1] || "";
+            if (!key) {
+                await ctx.reply(t("bot.subagents.usage", lang), { parse_mode: "Markdown" });
+                return;
+            }
+            const ambig = findSubAgentByName(key, { ambiguousAsList: true });
+            if (ambig && "ambiguous" in ambig) {
+                const list = ambig.candidates.map((c) => `• ${c.name}`).join("\n");
+                await ctx.reply(`Mehrdeutig — welchen meinst du?\n${list}`, { parse_mode: "Markdown" });
+                return;
+            }
+            let target = null;
+            if (ambig && !("ambiguous" in ambig)) {
+                target = { id: ambig.id, name: ambig.name };
+            }
+            else {
+                const allAgents = listSubAgents();
+                const byId = allAgents.find((a) => a.id.startsWith(key));
+                if (byId)
+                    target = { id: byId.id, name: byId.name };
+            }
+            if (!target) {
+                await ctx.reply(t("bot.subagents.notFound", lang, { id: key }));
+                return;
+            }
+            const result = getSubAgentResult(target.id);
+            if (!result) {
+                await ctx.reply(t("bot.subagents.notFound", lang, { id: key }));
+                return;
+            }
+            const duration = Math.floor(result.duration / 1000);
+            const header = t("bot.subagents.resultHeader", lang, { name: result.name, status: result.status });
+            const meta = t("bot.subagents.resultDuration", lang, { sec: duration, in: result.tokensUsed.input, out: result.tokensUsed.output });
+            // Cap output at ~3500 chars to stay inside Telegram message limit
+            const body = result.output.length > 3500 ? result.output.slice(0, 3500) + "\n\n…[truncated]" : result.output;
+            await ctx.reply(`${header}\n${meta}\n\n${body || result.error || "(no output)"}`, { parse_mode: "Markdown" }).catch(() => 
+            // retry without markdown in case the body has unescaped characters
+            ctx.reply(`${header}\n${meta}\n\n${body || result.error || "(no output)"}`));
+            return;
+        }
+        // Default: /sub-agents — show state + running list
+        const configured = getConfiguredMaxParallel();
+        const effective = getMaxParallelAgents();
+        const maxLabel = configured === 0
+            ? `${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 agents = listSubAgents();
+        let body = "";
+        if (agents.length === 0) {
+            body = `\n${t("bot.subagents.noneRunning", lang)}`;
         }
         else {
-            await ctx.reply("No running request.");
+            body = `\n${t("bot.subagents.activeHeader", lang)}\n${agents.map(formatAgent).join("\n")}`;
         }
+        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}`;
+        await ctx.reply(full, { parse_mode: "Markdown" }).catch(() => ctx.reply(full));
     });
 }