alvin-bot 4.5.0 → 4.6.0

package/dist/i18n.js

@@ -2,14 +2,19 @@
  * Alvin Bot — Internationalization (i18n)
  *
  * Simple key-based translation system.
- * Default: English. Supported: en, de.
+ * Default: English. Supported: en, de, es, fr.
  *
- * Detection order:
- *   1. --lang <en|de> CLI flag
- *   2. ALVIN_LANG env var
- *   3. LANG env var (e.g. de_DE.UTF-8 → de)
- *   4. Default: en
+ * Two usage patterns:
+ *   1. Global locale (for CLI/TUI where there's one user): call initI18n()
+ *      at startup, then t(key) reads the global currentLocale.
+ *   2. Per-call locale (for Telegram bot where every user has their own
+ *      language preference): t(key, userLocale) overrides the global.
+ *
+ * Simple {var} interpolation is supported: t("bot.error.timeout", "en", { min: 5 })
  */
+// Partial<Record<Locale,string>> so existing TUI/CLI keys can stay en+de only
+// without TypeScript forcing us to translate every single startup string to
+// es/fr. t() falls back to "en" when a locale is missing for a key.
 const strings = {
     // ── TUI ───────────────────────────────────────────────
     "tui.title": { en: "🤖 Alvin Bot TUI", de: "🤖 Alvin Bot TUI" },
@@ -161,6 +166,419 @@ const strings = {
     "update.done": { en: "Update complete!\n  Restart: pm2 restart alvin-bot", de: "Update abgeschlossen!\n  Neustarten: pm2 restart alvin-bot" },
     "update.npm": { en: "📦 Updating via npm...", de: "📦 Update via npm..." },
     "update.failed": { en: "Update failed:", de: "Update fehlgeschlagen:" },
+    // ══════════════════════════════════════════════════════
+    // ── Telegram bot commands (user-facing at runtime) ────
+    // All four locales (en/de/es/fr) are mandatory here because every
+    // Telegram user can pick any of them via /language.
+    // ══════════════════════════════════════════════════════
+    // /restart
+    "bot.restart.triggered": {
+        en: "♻️ Restart triggered — the bot will be back in a few seconds.",
+        de: "♻️ Restart wird ausgelöst — der Bot ist in wenigen Sekunden wieder da.",
+        es: "♻️ Reinicio activado — el bot volverá en unos segundos.",
+        fr: "♻️ Redémarrage déclenché — le bot sera de retour dans quelques secondes.",
+    },
+    // /update
+    "bot.update.checking": {
+        en: "🔄 Checking for updates…",
+        de: "🔄 Suche nach Updates…",
+        es: "🔄 Buscando actualizaciones…",
+        fr: "🔄 Recherche de mises à jour…",
+    },
+    "bot.update.restarting": {
+        en: "♻️ Restarting bot…",
+        de: "♻️ Bot wird neu gestartet…",
+        es: "♻️ Reiniciando el bot…",
+        fr: "♻️ Redémarrage du bot…",
+    },
+    "bot.update.failed": {
+        en: "❌ Update failed:",
+        de: "❌ Update fehlgeschlagen:",
+        es: "❌ Actualización fallida:",
+        fr: "❌ Échec de la mise à jour :",
+    },
+    "bot.update.error": {
+        en: "❌ Update error:",
+        de: "❌ Update-Fehler:",
+        es: "❌ Error de actualización:",
+        fr: "❌ Erreur de mise à jour :",
+    },
+    // /autoupdate
+    "bot.autoupdate.enabled": {
+        en: "✅ Auto-update *enabled* — checking every 6 h for new commits and installing them automatically.",
+        de: "✅ Auto-Update *aktiviert* — alle 6 h wird auf neue Commits geprüft und automatisch installiert.",
+        es: "✅ Auto-actualización *activada* — cada 6 h busca y aplica nuevos commits automáticamente.",
+        fr: "✅ Mise à jour automatique *activée* — vérification toutes les 6 h des nouveaux commits et installation automatique.",
+    },
+    "bot.autoupdate.disabled": {
+        en: "⏸️ Auto-update *disabled*.",
+        de: "⏸️ Auto-Update *deaktiviert*.",
+        es: "⏸️ Auto-actualización *desactivada*.",
+        fr: "⏸️ Mise à jour automatique *désactivée*.",
+    },
+    "bot.autoupdate.statusLabel": {
+        en: "Auto-update:",
+        de: "Auto-Update:",
+        es: "Auto-actualización:",
+        fr: "Mise à jour automatique :",
+    },
+    "bot.autoupdate.commandsLabel": {
+        en: "Commands:",
+        de: "Befehle:",
+        es: "Comandos:",
+        fr: "Commandes :",
+    },
+    // /status — session block
+    "bot.status.sessionHeader": {
+        en: "📊 *Session*",
+        de: "📊 *Session*",
+        es: "📊 *Sesión*",
+        fr: "📊 *Session*",
+    },
+    "bot.status.sessionNew": {
+        en: "🌱 New — send a message to start",
+        de: "🌱 Neu — sende eine Nachricht um zu starten",
+        es: "🌱 Nueva — envía un mensaje para empezar",
+        fr: "🌱 Nouvelle — envoie un message pour démarrer",
+    },
+    "bot.status.active": {
+        en: "🟢 Active",
+        de: "🟢 Aktiv",
+        es: "🟢 Activa",
+        fr: "🟢 Active",
+    },
+    "bot.status.idle": {
+        en: "💤 Idle",
+        de: "💤 Idle",
+        es: "💤 Inactiva",
+        fr: "💤 Inactive",
+    },
+    "bot.status.message": {
+        en: "message",
+        de: "Nachricht",
+        es: "mensaje",
+        fr: "message",
+    },
+    "bot.status.messages": {
+        en: "messages",
+        de: "Nachrichten",
+        es: "mensajes",
+        fr: "messages",
+    },
+    "bot.status.toolCall": {
+        en: "tool call",
+        de: "Tool-Call",
+        es: "llamada a herramienta",
+        fr: "appel d'outil",
+    },
+    "bot.status.toolCalls": {
+        en: "tool calls",
+        de: "Tool-Calls",
+        es: "llamadas a herramientas",
+        fr: "appels d'outils",
+    },
+    "bot.status.duration": {
+        en: "Duration",
+        de: "Dauer",
+        es: "Duración",
+        fr: "Durée",
+    },
+    "bot.status.lastTurn": {
+        en: "Last turn",
+        de: "Letzter Turn",
+        es: "Último turno",
+        fr: "Dernier tour",
+    },
+    "bot.status.lessThanMin": {
+        en: "< 1 min",
+        de: "< 1 Min",
+        es: "< 1 min",
+        fr: "< 1 min",
+    },
+    "bot.status.homeLabel": {
+        en: "Home",
+        de: "Home",
+        es: "Inicio",
+        fr: "Dossier personnel",
+    },
+    "bot.status.providerHealth": {
+        en: "💓 *Provider Health*",
+        de: "💓 *Provider-Status*",
+        es: "💓 *Estado de los proveedores*",
+        fr: "💓 *État des fournisseurs*",
+    },
+    "bot.status.failedOver": {
+        en: "⚠️ *FAILED OVER*",
+        de: "⚠️ *FAILOVER AKTIV*",
+        es: "⚠️ *FAILOVER ACTIVO*",
+        fr: "⚠️ *BASCULE ACTIVE*",
+    },
+    "bot.status.ollamaOnDemand": {
+        en: "(on-demand, not running)",
+        de: "(on-demand, läuft nicht)",
+        es: "(bajo demanda, no activo)",
+        fr: "(à la demande, non lancé)",
+    },
+    "bot.status.ollamaBotManaged": {
+        en: "(bot-managed, running)",
+        de: "(bot-verwaltet, läuft)",
+        es: "(gestionado por el bot, activo)",
+        fr: "(géré par le bot, en cours)",
+    },
+    "bot.status.ollamaExternal": {
+        en: "(external, running)",
+        de: "(extern, läuft)",
+        es: "(externo, activo)",
+        fr: "(externe, en cours)",
+    },
+    // /cancel
+    "bot.cancel.cancelling": {
+        en: "Cancelling request…",
+        de: "Anfrage wird abgebrochen…",
+        es: "Cancelando la solicitud…",
+        fr: "Annulation de la requête…",
+    },
+    "bot.cancel.noRunning": {
+        en: "No running request.",
+        de: "Keine laufende Anfrage.",
+        es: "No hay ninguna solicitud en curso.",
+        fr: "Aucune requête en cours.",
+    },
+    // /model
+    "bot.model.chooseHeader": {
+        en: "🤖 *Choose model:*",
+        de: "🤖 *Modell wählen:*",
+        es: "🤖 *Elige modelo:*",
+        fr: "🤖 *Choisis un modèle :*",
+    },
+    "bot.model.active": {
+        en: "Active:",
+        de: "Aktiv:",
+        es: "Activo:",
+        fr: "Actif :",
+    },
+    "bot.model.switched": {
+        en: "✅ Switched model:",
+        de: "✅ Modell gewechselt:",
+        es: "✅ Modelo cambiado:",
+        fr: "✅ Modèle changé :",
+    },
+    "bot.model.switchFailed": {
+        en: "❌ Switch failed:",
+        de: "❌ Wechsel fehlgeschlagen:",
+        es: "❌ Cambio fallido:",
+        fr: "❌ Échec du changement :",
+    },
+    "bot.model.notFoundHint": {
+        en: "Use /model to see all options.",
+        de: "Nutze /model um alle Optionen zu sehen.",
+        es: "Usa /model para ver todas las opciones.",
+        fr: "Utilise /model pour voir toutes les options.",
+    },
+    "bot.model.bootFailed": {
+        en: "failed to start {key} daemon (is it installed?)",
+        de: "Start des {key}-Daemons fehlgeschlagen (ist er installiert?)",
+        es: "no se pudo iniciar el daemon de {key} (¿está instalado?)",
+        fr: "échec du démarrage du daemon {key} (est-il installé ?)",
+    },
+    // /lang
+    "bot.lang.header": {
+        en: "🌐 *Language:*",
+        de: "🌐 *Sprache:*",
+        es: "🌐 *Idioma:*",
+        fr: "🌐 *Langue :*",
+    },
+    "bot.lang.autoEnabled": {
+        en: "🔄 Auto-detection enabled. I'll adapt to the language you write in.",
+        de: "🔄 Auto-Erkennung aktiv. Ich passe mich deiner Sprache an.",
+        es: "🔄 Detección automática activada. Me adaptaré al idioma en que escribas.",
+        fr: "🔄 Détection automatique activée. Je m'adapterai à la langue que tu écris.",
+    },
+    "bot.lang.setFixed": {
+        en: "✅ Language: {name} (fixed)",
+        de: "✅ Sprache: {name} (fest)",
+        es: "✅ Idioma: {name} (fijo)",
+        fr: "✅ Langue : {name} (fixe)",
+    },
+    "bot.lang.usage": {
+        en: "Use: `/lang de`, `/lang en`, `/lang es`, `/lang fr`, or `/lang auto`",
+        de: "Nutze: `/lang de`, `/lang en`, `/lang es`, `/lang fr`, oder `/lang auto`",
+        es: "Usa: `/lang de`, `/lang en`, `/lang es`, `/lang fr`, o `/lang auto`",
+        fr: "Utilise : `/lang de`, `/lang en`, `/lang es`, `/lang fr`, ou `/lang auto`",
+    },
+    "bot.lang.autoDetect": {
+        en: "🔄 Auto-detect",
+        de: "🔄 Auto-Erkennung",
+        es: "🔄 Auto-detectar",
+        fr: "🔄 Détection auto",
+    },
+    // Errors (in the message handler)
+    // Adaptive timeout: two distinct messages for "stuck" (no progress) vs
+    // "absolute max" (total runtime cap) so the user understands WHICH limit
+    // was hit. Prior single "bot.error.timeout" is kept as a backward-compat
+    // alias pointing at the stuck variant.
+    "bot.error.timeoutStuck": {
+        en: "⏱️ No response for {min} minutes — Claude seems stuck. Request aborted.",
+        de: "⏱️ Keine Antwort seit {min} Minuten — Claude scheint hängen geblieben zu sein. Abgebrochen.",
+        es: "⏱️ Sin respuesta durante {min} minutos — Claude parece atascado. Solicitud cancelada.",
+        fr: "⏱️ Aucune réponse depuis {min} minutes — Claude semble bloqué. Requête annulée.",
+    },
+    "bot.error.timeoutMax": {
+        en: "⏱️ Maximum runtime ({min} minutes) reached. Request aborted.",
+        de: "⏱️ Maximale Laufzeit ({min} Minuten) erreicht. Abgebrochen.",
+        es: "⏱️ Tiempo máximo de ejecución ({min} minutos) alcanzado. Solicitud cancelada.",
+        fr: "⏱️ Durée maximale ({min} minutes) atteinte. Requête annulée.",
+    },
+    "bot.error.timeout": {
+        // Backward-compat alias — points at the stuck variant so older callers
+        // still work. New code should prefer timeoutStuck / timeoutMax.
+        en: "⏱️ No response for {min} minutes — Claude seems stuck. Request aborted.",
+        de: "⏱️ Keine Antwort seit {min} Minuten — Claude scheint hängen geblieben zu sein. Abgebrochen.",
+        es: "⏱️ Sin respuesta durante {min} minutos — Claude parece atascado. Solicitud cancelada.",
+        fr: "⏱️ Aucune réponse depuis {min} minutes — Claude semble bloqué. Requête annulée.",
+    },
+    "bot.error.requestCancelled": {
+        en: "Request cancelled.",
+        de: "Anfrage abgebrochen.",
+        es: "Solicitud cancelada.",
+        fr: "Requête annulée.",
+    },
+    "bot.error.prefix": {
+        en: "Error:",
+        de: "Fehler:",
+        es: "Error:",
+        fr: "Erreur :",
+    },
+    // This is a composed error used in registry.ts mid-stream failure.
+    // {name} = provider display name, {detail} = the upstream error.
+    "bot.error.midStream": {
+        en: "{name} was interrupted mid-stream: {detail}. Please send the request again.",
+        de: "{name} wurde mid-stream unterbrochen: {detail}. Bitte Anfrage erneut senden.",
+        es: "{name} se interrumpió a mitad de flujo: {detail}. Por favor envía la solicitud de nuevo.",
+        fr: "{name} a été interrompu en cours de flux : {detail}. Veuillez renvoyer la requête.",
+    },
+    // /sub-agents command
+    "bot.subagents.header": {
+        en: "🤖 *Sub-Agents*",
+        de: "🤖 *Sub-Agents*",
+        es: "🤖 *Sub-Agentes*",
+        fr: "🤖 *Sous-agents*",
+    },
+    "bot.subagents.maxLabel": {
+        en: "Max parallel:",
+        de: "Max parallel:",
+        es: "Máx. paralelos:",
+        fr: "Max parallèles :",
+    },
+    "bot.subagents.autoSuffix": {
+        en: "(auto = {n})",
+        de: "(auto = {n})",
+        es: "(auto = {n})",
+        fr: "(auto = {n})",
+    },
+    "bot.subagents.noneRunning": {
+        en: "No agents running or recently completed.",
+        de: "Keine Agents aktiv oder kürzlich beendet.",
+        es: "Ningún agente en ejecución o recién finalizado.",
+        fr: "Aucun agent en cours ou récemment terminé.",
+    },
+    "bot.subagents.activeHeader": {
+        en: "Active / Recent:",
+        de: "Aktiv / Kürzlich:",
+        es: "Activos / Recientes:",
+        fr: "Actifs / Récents :",
+    },
+    "bot.subagents.maxSet": {
+        en: "✅ Max parallel set to {n} (effective: {eff})",
+        de: "✅ Max parallel auf {n} gesetzt (effektiv: {eff})",
+        es: "✅ Máx. paralelos establecido en {n} (efectivo: {eff})",
+        fr: "✅ Max parallèles défini à {n} (effectif : {eff})",
+    },
+    "bot.subagents.cancelled": {
+        en: "🛑 Cancelled agent {id}",
+        de: "🛑 Agent {id} abgebrochen",
+        es: "🛑 Agente {id} cancelado",
+        fr: "🛑 Agent {id} annulé",
+    },
+    "bot.subagents.notFound": {
+        en: "❌ Agent {id} not found or not running",
+        de: "❌ Agent {id} nicht gefunden oder nicht aktiv",
+        es: "❌ Agente {id} no encontrado o inactivo",
+        fr: "❌ Agent {id} introuvable ou inactif",
+    },
+    "bot.subagents.resultHeader": {
+        en: "🤖 Agent: {name} ({status})",
+        de: "🤖 Agent: {name} ({status})",
+        es: "🤖 Agente: {name} ({status})",
+        fr: "🤖 Agent : {name} ({status})",
+    },
+    "bot.subagents.resultDuration": {
+        en: "Duration: {sec}s · Tokens: {in}/{out}",
+        de: "Dauer: {sec}s · Tokens: {in}/{out}",
+        es: "Duración: {sec}s · Tokens: {in}/{out}",
+        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> — delivery mode\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> — 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> — 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> — 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:",
+        de: "Sichtbarkeit:",
+        es: "Visibilidad:",
+        fr: "Visibilité :",
+    },
+    "bot.subagents.visibilitySet": {
+        en: "✅ Visibility set to *{mode}*",
+        de: "✅ Sichtbarkeit auf *{mode}* gesetzt",
+        es: "✅ Visibilidad establecida a *{mode}*",
+        fr: "✅ Visibilité réglée sur *{mode}*",
+    },
+    "bot.subagents.visibilityInvalid": {
+        en: "❌ Invalid mode _{mode}_. Use: auto | banner | silent",
+        de: "❌ Ungültiger Modus _{mode}_. Nutze: auto | banner | silent",
+        es: "❌ Modo inválido _{mode}_. Usa: auto | banner | silent",
+        fr: "❌ Mode invalide _{mode}_. Utilise : auto | banner | silent",
+    },
+    // Relative time formatting (formatRelativeTime helper)
+    "bot.time.justNow": {
+        en: "just now",
+        de: "gerade eben",
+        es: "justo ahora",
+        fr: "à l'instant",
+    },
+    "bot.time.secondsAgo": {
+        en: "{n}s ago",
+        de: "vor {n} s",
+        es: "hace {n} s",
+        fr: "il y a {n} s",
+    },
+    "bot.time.minutesAgo": {
+        en: "{n}min ago",
+        de: "vor {n} min",
+        es: "hace {n} min",
+        fr: "il y a {n} min",
+    },
+    "bot.time.hoursAgo": {
+        en: "{n}h ago",
+        de: "vor {n} h",
+        es: "hace {n} h",
+        fr: "il y a {n} h",
+    },
+    "bot.time.dayAgo": {
+        en: "{n} day ago",
+        de: "vor {n} Tag",
+        es: "hace {n} día",
+        fr: "il y a {n} jour",
+    },
+    "bot.time.daysAgo": {
+        en: "{n} days ago",
+        de: "vor {n} Tagen",
+        es: "hace {n} días",
+        fr: "il y a {n} jours",
+    },
     // ── Default SOUL.md ───────────────────────────────────
     "soul.default": {
         en: `# SOUL.md — Your Bot's Personality
@@ -263,21 +681,25 @@ Ich bin nicht statisch. Im Laufe unserer Interaktion lerne ich deine Präferenze
 };
 // ── Runtime ─────────────────────────────────────────────
 let currentLocale = "en";
+const SUPPORTED_LOCALES = ["en", "de", "es", "fr"];
+function isLocale(v) {
+    return !!v && SUPPORTED_LOCALES.includes(v);
+}
 /**
  * Detect locale from CLI flags and environment.
- * Only explicit opt-in switches to German:
- *   --lang de | ALVIN_LANG=de
+ * Explicit opt-in only:
+ *   --lang <en|de|es|fr> | ALVIN_LANG=<en|de|es|fr>
  * System LANG is NOT used (too many false positives on multilingual systems).
  */
 export function detectLocale() {
     const langIdx = process.argv.indexOf("--lang");
     if (langIdx !== -1) {
         const val = process.argv[langIdx + 1]?.toLowerCase();
-        if (val === "de" || val === "en")
+        if (isLocale(val))
             return val;
     }
     const envLang = process.env.ALVIN_LANG?.toLowerCase();
-    if (envLang === "de" || envLang === "en")
+    if (isLocale(envLang))
         return envLang;
     return "en";
 }
@@ -293,7 +715,42 @@ export function getLocale() {
 export function setLocale(locale) {
     currentLocale = locale;
 }
-/** Translate a key. Returns the key itself if not found. */
-export function t(key) {
-    return strings[key]?.[currentLocale] || strings[key]?.["en"] || key;
+/**
+ * Simple {var} interpolation. Missing vars leave the placeholder intact
+ * so bugs are visible rather than swallowed silently.
+ */
+function interpolate(template, vars) {
+    return template.replace(/\{(\w+)\}/g, (_, key) => {
+        const v = vars[key];
+        return v !== undefined ? String(v) : `{${key}}`;
+    });
 }
+/**
+ * Translate a key.
+ *
+ * - If `locale` is passed, it overrides the global currentLocale (this is
+ *   what the Telegram bot handlers use to pick each user's own language).
+ * - Falls back to English if the key is missing in the requested locale.
+ * - Falls back to the key itself if missing everywhere (makes missing
+ *   translations visible in the UI rather than silent empty strings).
+ * - Optional {var} interpolation via the third parameter.
+ */
+export function t(key, locale, vars) {
+    const loc = locale || currentLocale;
+    const raw = strings[key]?.[loc] || strings[key]?.["en"] || key;
+    return vars ? interpolate(raw, vars) : raw;
+}
+/** Human-readable language names in their own language. */
+export const LOCALE_NAMES = {
+    en: "English",
+    de: "Deutsch",
+    es: "Español",
+    fr: "Français",
+};
+/** Flag emoji for a locale. Used in the /language keyboard. */
+export const LOCALE_FLAGS = {
+    en: "🇬🇧",
+    de: "🇩🇪",
+    es: "🇪🇸",
+    fr: "🇫🇷",
+};

package/dist/index.js

@@ -28,15 +28,22 @@ if (config.allowedUsers.length === 0 && hasTelegram) {
     console.warn("⚠️  ALLOWED_USERS not set — nobody can message the Telegram bot yet.");
     console.warn("   Send /start to @userinfobot on Telegram to find your ID.");
 }
-// Check if the chosen provider has a corresponding API key
+// Check if the chosen provider has a corresponding API key.
+// Keys here MUST match the registry keys from src/providers/registry.ts
+// (createRegistry). Providers that authenticate differently (claude-sdk
+// via OAuth, codex-cli/ollama via local binary) are deliberately absent.
+// Custom providers from docs/custom-models.json handle their own apiKeyEnv.
 const providerKeyMap = {
+    google: "GOOGLE_API_KEY",
+    // Legacy custom-model aliases kept so older configs don't break their
+    // pre-flight warning — if users have these as primary they're coming
+    // from docs/custom-models.json.
     groq: "GROQ_API_KEY",
+    openai: "OPENAI_API_KEY",
+    openrouter: "OPENROUTER_API_KEY",
     "nvidia-llama-3.3-70b": "NVIDIA_API_KEY",
     "nvidia-kimi-k2.5": "NVIDIA_API_KEY",
-    "gemini-2.5-flash": "GOOGLE_API_KEY",
-    openai: "OPENAI_API_KEY",
     "gpt-4o": "OPENAI_API_KEY",
-    openrouter: "OPENROUTER_API_KEY",
 };
 const requiredKey = providerKeyMap[config.primaryProvider];
 if (requiredKey) {
@@ -69,6 +76,7 @@ import { loadSkills } from "./services/skills.js";
 import { loadHooks } from "./services/hooks.js";
 import { registerShutdownHandler } from "./services/restart.js";
 import { cancelAllSubAgents } from "./services/subagents.js";
+import { getRegistry } from "./engine.js";
 import { scanAssets } from "./services/asset-index.js";
 // Scan asset directory and generate INDEX.json + INDEX.md
 const assetScanResult = scanAssets();
@@ -118,6 +126,15 @@ if (hasMCPConfig()) {
 let bot = null;
 if (hasTelegram) {
     bot = new Bot(config.botToken);
+    // Wire the sub-agent delivery router so async agent finals can reach
+    // Telegram (cron-spawned agents, user-spawned async finals, shutdown
+    // cancellation notifications). Lazy-import avoids a top-level cycle.
+    const { attachBotApi } = await import("./services/subagent-delivery.js");
+    const botRef = bot;
+    attachBotApi({
+        sendMessage: (chatId, text, opts) => botRef.api.sendMessage(chatId, text, opts),
+        sendDocument: (chatId, doc, opts) => botRef.api.sendDocument(chatId, doc, opts),
+    });
     // Auth middleware — alle Messages durchlaufen das
     bot.use(authMiddleware);
     // Commands registrieren
@@ -213,7 +230,10 @@ const shutdown = async () => {
         return;
     isShuttingDown = true;
     console.log("Graceful shutdown initiated...");
-    cancelAllSubAgents();
+    // E2: shutdown-notification — await the async cancellation so running
+    // agents can post a cancellation message to Telegram before the bot
+    // stops. Capped at 5s internally so a hang can't block shutdown.
+    await cancelAllSubAgents(true);
     stopScheduler();
     stopSessionCleanup();
     if (queueInterval)
@@ -224,6 +244,25 @@ const shutdown = async () => {
         bot.stop();
     await unloadPlugins().catch(() => { });
     await disconnectMCP().catch(() => { });
+    // Tear down any bot-managed local runners (Ollama, LM Studio, …) so VRAM
+    // is freed and no daemon outlives the bot as a zombie. Iterates generically
+    // over every registered provider that exposes a lifecycle.
+    try {
+        const registry = getRegistry();
+        const providers = await registry.listAll();
+        for (const p of providers) {
+            const provider = registry.get(p.key);
+            if (provider?.lifecycle?.isBotManaged()) {
+                console.log(`Tearing down bot-managed ${p.key}...`);
+                await provider.lifecycle.ensureStopped().catch((err) => {
+                    console.warn(`${p.key} shutdown teardown failed:`, err);
+                });
+            }
+        }
+    }
+    catch (err) {
+        console.warn("lifecycle teardown failed:", err);
+    }
     console.log("Goodbye! 👋");
     process.exit(0);
 };