alvin-bot 4.5.1 → 4.7.0

package/dist/services/cron.js

@@ -12,7 +12,6 @@
 import fs from "fs";
 import { execSync } from "child_process";
 import { dirname } from "path";
-import { getRegistry } from "../engine.js";
 import { CRON_FILE, BOT_ROOT } from "../paths.js";
 // ── Storage ─────────────────────────────────────────────
 function loadJobs() {
@@ -151,52 +150,61 @@ async function executeJob(job) {
                 return { output };
             }
             case "ai-query": {
-                // AI queries run through the actual AI engine (Claude SDK)
+                // AI queries run as isolated sub-agents rather than directly against
+                // the registry. This gives cron jobs timeout/cancel/state-tracking
+                // "for free" via the existing subagents infrastructure, and — most
+                // importantly — keeps them completely independent of any user's
+                // active main session. A cron job can run in the background while
+                // the user chats with Alvin in the foreground; neither interferes
+                // with the other.
                 const prompt = job.payload.prompt || "";
+                // Dynamic import to avoid circular dep chain (cron → engine → registry
+                // and subagents → engine). Type-only import at file top is erased,
+                // so no runtime cycle is created.
+                const { spawnSubAgent } = await import("./subagents.js");
                 try {
-                    const registry = getRegistry();
-                    const queryOpts = {
-                        prompt,
-                        systemPrompt: `You are Alvin Bot, an autonomous AI assistant. You are currently executing a scheduled cron job ("${job.name}"). Reply concisely. Use Telegram-compatible Markdown. You have access to tools (Bash, files, etc.) — use them if needed.`,
-                        effort: "high",
-                        workingDir: BOT_ROOT,
-                    };
-                    let fullResponse = "";
-                    for await (const chunk of registry.queryWithFallback(queryOpts)) {
-                        if (chunk.type === "text" && chunk.text) {
-                            fullResponse = chunk.text;
-                        }
-                        if (chunk.type === "error") {
-                            throw new Error(chunk.error || "AI query failed");
-                        }
-                        if (chunk.type === "done") {
-                            break;
-                        }
-                    }
-                    // Send AI response to target
-                    if (notifyCallback && fullResponse.trim()) {
-                        // Split long responses into chunks (Telegram limit ~4096 chars)
-                        const maxLen = 3900;
-                        if (fullResponse.length <= maxLen) {
-                            await notifyCallback(job.target, fullResponse);
-                        }
-                        else {
-                            const parts = [];
-                            for (let i = 0; i < fullResponse.length; i += maxLen) {
-                                parts.push(fullResponse.slice(i, i + maxLen));
-                            }
-                            for (const part of parts) {
-                                await notifyCallback(job.target, part);
-                            }
-                        }
+                    // Turn the fire-and-forget spawnSubAgent into an awaitable via
+                    // the onComplete callback. Rejection of the spawn promise itself
+                    // means the max-parallel limit was hit.
+                    // Parse the target chat id for I3 delivery routing. Only telegram
+                    // targets get a numeric parentChatId — other platforms/web get
+                    // undefined and fall through the delivery router's warning path.
+                    const parentChatId = job.target.platform === "telegram" && job.target.chatId
+                        ? Number(job.target.chatId)
+                        : undefined;
+                    const result = await new Promise((resolve, reject) => {
+                        spawnSubAgent({
+                            name: job.name,
+                            prompt,
+                            workingDir: BOT_ROOT,
+                            source: "cron",
+                            parentChatId,
+                            onComplete: (r) => resolve(r),
+                        }).catch(reject);
+                    });
+                    // Non-success: don't notify here. The I3 delivery router has
+                    // already posted the appropriate banner (cancelled / timeout /
+                    // error) to parentChatId, so a legacy notifyCallback would
+                    // produce a duplicate message.
+                    if (result.status !== "completed") {
+                        return {
+                            output: "",
+                            error: `Sub-agent ${result.status}: ${result.error || result.status}`,
+                        };
                     }
+                    const fullResponse = result.output;
+                    // NOTE: No notifyCallback for ai-query jobs. The I3 delivery
+                    // router (src/services/subagent-delivery.ts) fires from
+                    // spawnSubAgent().finally() and sends a proper banner+final to
+                    // parentChatId. Legacy notifyCallback stays in use for the
+                    // other job types (reminder, shell, http, message) which do
+                    // not route through spawnSubAgent.
                     return { output: fullResponse.slice(0, 500) };
                 }
                 catch (err) {
-                    const error = err instanceof Error ? err.message : String(err);
-                    if (notifyCallback) {
-                        await notifyCallback(job.target, `❌ AI-Query Error (${job.name}): ${error}`);
-                    }
+                    // Re-throw without notifying — the outer catch will record
+                    // lastError on the job, and the I3 delivery router has already
+                    // posted a banner if the failure came from inside spawnSubAgent.
                     throw err;
                 }
             }
@@ -206,7 +214,10 @@ async function executeJob(job) {
     }
     catch (err) {
         const error = err instanceof Error ? err.message : String(err);
-        if (notifyCallback) {
+        // Skip notification for ai-query jobs — the I3 delivery router has
+        // already posted the banner. Other job types still get the legacy
+        // notify path because they don't route through spawnSubAgent.
+        if (notifyCallback && job.type !== "ai-query") {
             await notifyCallback(job.target, `❌ Cron Error (${job.name}): ${error}`);
         }
         return { output: "", error };

package/dist/services/heartbeat.js

@@ -101,6 +101,18 @@ async function runHeartbeat() {
         const provider = registry.get(key);
         if (!provider)
             continue;
+        // Providers with an on-demand lifecycle (local runners: Ollama, LM
+        // Studio, llama.cpp, …) are not pinged periodically — they're off
+        // until we actively boot them during failover. Mark as always-healthy
+        // so they remain a valid failover target.
+        if (provider.lifecycle) {
+            health.healthy = true;
+            health.lastCheck = Date.now();
+            health.lastLatencyMs = 0;
+            health.failCount = 0;
+            health.lastError = undefined;
+            continue;
+        }
         const start = Date.now();
         try {
             // Quick availability check first
@@ -142,7 +154,7 @@ async function runHeartbeat() {
         }
     }
     // Auto-failover logic
-    handleFailover(registry);
+    await handleFailover(registry);
 }
 async function pingProvider(provider, key) {
     // For CLI-based providers, just check availability (no full query needed)
@@ -166,7 +178,7 @@ async function pingProvider(provider, key) {
     }
     return text || "ok";
 }
-function handleFailover(registry) {
+async function handleFailover(registry) {
     const primaryHealth = state.providers.get(state.originalPrimary);
     const currentKey = registry.getActiveKey();
     // Case 1: Primary is down → switch to first healthy fallback
@@ -174,19 +186,41 @@ function handleFailover(registry) {
         const fallbackOrder = config.fallbackProviders;
         for (const fbKey of fallbackOrder) {
             const fbHealth = state.providers.get(fbKey);
-            if (fbHealth?.healthy) {
+            if (!fbHealth?.healthy)
+                continue;
+            const fbProvider = registry.get(fbKey);
+            if (!fbProvider)
+                continue;
+            // Providers with a lifecycle (local runners) must be booted before
+            // the switch. If boot fails, skip and try the next fallback.
+            if (fbProvider.lifecycle) {
+                console.log(`💓 🔄 Auto-failover: ${state.originalPrimary} → ${fbKey} — booting ${fbKey}…`);
+                const ok = await fbProvider.lifecycle.ensureRunning();
+                if (!ok) {
+                    console.log(`💓 ⚠️ ${fbKey} boot failed — skipping`);
+                    continue;
+                }
+            }
+            else {
                 console.log(`💓 🔄 Auto-failover: ${state.originalPrimary} → ${fbKey}`);
-                registry.switchTo(fbKey);
-                state.wasFailedOver = true;
-                return;
             }
+            registry.switchTo(fbKey);
+            state.wasFailedOver = true;
+            return;
         }
         console.log("💓 ⚠️ All providers unhealthy — staying on primary");
+        return;
     }
-    // Case 2: Primary recovered → switch back
+    // Case 2: Primary recovered → switch back, tearing down any lifecycle-
+    // managed fallback we booted during the outage.
     if (primaryHealth?.healthy && state.wasFailedOver && currentKey !== state.originalPrimary) {
+        const currentProvider = registry.get(currentKey);
         console.log(`💓 ✅ Primary recovered — switching back to ${state.originalPrimary}`);
         registry.switchTo(state.originalPrimary);
         state.wasFailedOver = false;
+        if (currentProvider?.lifecycle) {
+            console.log(`💓 🧹 Tearing down ${currentKey} daemon + unloading model`);
+            await currentProvider.lifecycle.ensureStopped();
+        }
     }
 }

package/dist/services/language-detect.js

@@ -83,12 +83,18 @@ export function detectLanguage(text) {
 /**
  * Update language statistics for a user and auto-adapt if pattern is clear.
  * Returns the recommended language for this session.
+ *
+ * Note: auto-detection is intentionally limited to de/en (the two languages
+ * our heuristic covers). For es/fr users, the /language command is the only
+ * way to set their UI locale — their explicit choice is persisted via
+ * profile.langExplicit and trackAndAdapt returns it untouched.
  */
 export function trackAndAdapt(userId, text, currentSessionLang) {
     const profile = loadProfile(userId);
     if (!profile)
         return currentSessionLang;
-    // If user explicitly set language, don't auto-switch
+    // If user explicitly set language (via /language), honour it and never
+    // auto-switch. This is the only way es/fr get persisted.
     if (profile.langExplicit)
         return profile.language;
     const detected = detectLanguage(text);
@@ -115,7 +121,10 @@ export function trackAndAdapt(userId, text, currentSessionLang) {
         }
     }
     else {
-        // Early phase: follow immediate language for responsiveness
+        // Early phase: follow immediate language for responsiveness.
+        // Only overrides es/fr if the user wrote in de/en without having set
+        // langExplicit — which can only happen if they changed language via
+        // something other than /language (shouldn't happen in practice).
         profile.language = detected;
     }
     saveProfile(profile);
@@ -123,6 +132,7 @@ export function trackAndAdapt(userId, text, currentSessionLang) {
 }
 /**
  * Mark language as explicitly set by user (disables auto-detection).
+ * Accepts all supported locales including es/fr.
  */
 export function setExplicitLanguage(userId, lang) {
     const profile = loadProfile(userId);

package/dist/services/ollama-manager.js

@@ -0,0 +1,339 @@
+/**
+ * Ollama Manager — on-demand daemon lifecycle for fallback use.
+ *
+ * The bot uses Ollama as a local fallback when the primary provider is down.
+ * Historically the user had to run `ollama serve` themselves — if they forgot,
+ * the fallback silently failed. This service spawns the daemon on demand,
+ * preloads the target model into VRAM, and tears it all down once the primary
+ * provider is healthy again.
+ *
+ * Key invariants:
+ *   • Only kills instances the bot started itself (tracked via PID file).
+ *     An externally-managed ollama is left alone.
+ *   • Preload uses Ollama's native /api/generate endpoint with an empty
+ *     prompt and keep_alive=30m, so the first real query is not cold.
+ *   • Unload sets keep_alive=0 to flush the model from VRAM immediately.
+ *   • All spawns are detached with stdio=ignore, so the child survives the
+ *     bot crashing but still gets cleaned up on graceful shutdown.
+ */
+import { spawn, execFile } from "child_process";
+import { promisify } from "util";
+import fs from "fs";
+import { resolve, dirname } from "path";
+import os from "os";
+const execFileAsync = promisify(execFile);
+const DATA_DIR = process.env.ALVIN_DATA_DIR || resolve(os.homedir(), ".alvin-bot");
+const PID_FILE = resolve(DATA_DIR, "ollama.pid");
+const MODEL_FILE = resolve(DATA_DIR, "ollama.model");
+const OLLAMA_API_BASE = "http://localhost:11434";
+const DAEMON_READY_TIMEOUT_MS = 15_000;
+const PRELOAD_TIMEOUT_MS = 60_000;
+const KEEP_ALIVE = "30m";
+let managedProcess = null;
+let managedModel = null;
+// ── PID / Process verification ─────────────────────────────────────────────
+/**
+ * Verify that `pid` is actually an ollama process by inspecting its command
+ * via `ps`. This prevents the classic PID-reuse bug where we'd kill a
+ * random process after a bot crash left a stale pid file pointing at
+ * something the OS has since re-assigned.
+ */
+async function verifyPidIsOllama(pid) {
+    try {
+        const { stdout } = await execFileAsync("ps", ["-p", String(pid), "-o", "command="], {
+            timeout: 3_000,
+        });
+        return stdout.toLowerCase().includes("ollama");
+    }
+    catch {
+        // ps exits non-zero if pid doesn't exist — treat as "not ollama"
+        return false;
+    }
+}
+function loadManagedModelFromDisk() {
+    try {
+        if (fs.existsSync(MODEL_FILE)) {
+            return fs.readFileSync(MODEL_FILE, "utf-8").trim() || null;
+        }
+    }
+    catch { /* ignore */ }
+    return null;
+}
+function persistManagedModel(model) {
+    try {
+        fs.mkdirSync(dirname(MODEL_FILE), { recursive: true });
+        if (model) {
+            fs.writeFileSync(MODEL_FILE, model, "utf-8");
+        }
+        else if (fs.existsSync(MODEL_FILE)) {
+            fs.unlinkSync(MODEL_FILE);
+        }
+    }
+    catch (err) {
+        console.warn(`[ollama] failed to persist model file: ${err}`);
+    }
+}
+/**
+ * Reconcile stale state left behind from a previous bot run.
+ * If the PID file points at a process that is no longer ollama (crashed,
+ * PID reused, never existed), remove the file so we don't try to kill
+ * the wrong process later. Called lazily from ensureRunning / ensureStopped.
+ */
+async function reconcileStalePidFile() {
+    if (!fs.existsSync(PID_FILE))
+        return;
+    try {
+        const raw = fs.readFileSync(PID_FILE, "utf-8").trim();
+        const pid = parseInt(raw, 10);
+        if (isNaN(pid) || pid <= 0) {
+            fs.unlinkSync(PID_FILE);
+            return;
+        }
+        const isOllama = await verifyPidIsOllama(pid);
+        if (!isOllama) {
+            console.log(`[ollama] stale pid file (pid=${pid} is no longer ollama) — removing`);
+            fs.unlinkSync(PID_FILE);
+            persistManagedModel(null);
+        }
+    }
+    catch {
+        // If we can't read/parse it, drop it
+        try {
+            fs.unlinkSync(PID_FILE);
+        }
+        catch { /* ignore */ }
+    }
+}
+export async function isDaemonRunning() {
+    try {
+        const res = await fetch(`${OLLAMA_API_BASE}/api/tags`, {
+            signal: AbortSignal.timeout(2_000),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function findOllamaBinary() {
+    // Common install paths — macOS Homebrew, Linux, /usr/local
+    const candidates = [
+        "/opt/homebrew/bin/ollama",
+        "/usr/local/bin/ollama",
+        "/usr/bin/ollama",
+    ];
+    for (const p of candidates) {
+        if (fs.existsSync(p))
+            return p;
+    }
+    // Fallback: `which ollama` (async, no event-loop block)
+    try {
+        const { stdout } = await execFileAsync("which", ["ollama"], { timeout: 3_000 });
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function waitForDaemon(timeoutMs = DAEMON_READY_TIMEOUT_MS) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        if (await isDaemonRunning())
+            return true;
+        await new Promise(r => setTimeout(r, 500));
+    }
+    return false;
+}
+async function preloadModel(model) {
+    try {
+        await fetch(`${OLLAMA_API_BASE}/api/generate`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                model,
+                prompt: "",
+                keep_alive: KEEP_ALIVE,
+            }),
+            signal: AbortSignal.timeout(PRELOAD_TIMEOUT_MS),
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`[ollama] preload warning (model=${model}): ${msg}`);
+    }
+}
+async function unloadModel(model) {
+    try {
+        await fetch(`${OLLAMA_API_BASE}/api/generate`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                model,
+                keep_alive: 0, // immediate VRAM unload
+            }),
+            signal: AbortSignal.timeout(5_000),
+        });
+    }
+    catch {
+        // ignore — daemon may already be stopping
+    }
+}
+/**
+ * Ensure the Ollama daemon is running and the specified model is loaded.
+ * Idempotent. If an externally-managed daemon is already running, we use
+ * it and just preload the model, but leave it for ensureStopped() to decide
+ * whether to kill it (it won't — only bot-spawned daemons get killed).
+ */
+export async function ensureRunning(model) {
+    // Drop any stale pid file from a previous run before deciding anything.
+    await reconcileStalePidFile();
+    if (await isDaemonRunning()) {
+        // Daemon is already up — either we started it in a previous bot run
+        // (pid file still valid) or user started it externally (no pid file).
+        // In both cases we preload the target model so the first query is warm.
+        await preloadModel(model);
+        managedModel = model;
+        // If a valid pid file exists, we inherit ownership of that daemon
+        // (it was bot-managed before a crash/restart). Update the model file.
+        if (fs.existsSync(PID_FILE)) {
+            persistManagedModel(model);
+        }
+        return true;
+    }
+    const binary = await findOllamaBinary();
+    if (!binary) {
+        console.error("[ollama] binary not found — install ollama first (brew install ollama)");
+        return false;
+    }
+    console.log(`[ollama] starting daemon: ${binary} serve`);
+    const proc = spawn(binary, ["serve"], {
+        detached: true,
+        stdio: "ignore",
+        env: process.env,
+    });
+    proc.unref();
+    if (!proc.pid) {
+        console.error("[ollama] spawn failed — no pid");
+        return false;
+    }
+    // Persist the PID + model so we can kill/unload correctly on cleanup,
+    // even after a bot restart loses the in-memory references.
+    try {
+        fs.mkdirSync(dirname(PID_FILE), { recursive: true });
+        fs.writeFileSync(PID_FILE, String(proc.pid), "utf-8");
+        persistManagedModel(model);
+    }
+    catch (err) {
+        console.warn(`[ollama] failed to write state files: ${err}`);
+    }
+    managedProcess = proc;
+    managedModel = model;
+    const ready = await waitForDaemon();
+    if (!ready) {
+        console.error("[ollama] daemon did not become ready within 15s");
+        // Clean up: we spawned something that didn't come up. Best effort kill.
+        try {
+            process.kill(proc.pid, "SIGTERM");
+        }
+        catch { /* ignore */ }
+        try {
+            fs.unlinkSync(PID_FILE);
+        }
+        catch { /* ignore */ }
+        persistManagedModel(null);
+        return false;
+    }
+    console.log(`[ollama] daemon ready — preloading model: ${model}`);
+    await preloadModel(model);
+    return true;
+}
+/**
+ * Stop the daemon if we started it, unload the model from VRAM.
+ * Does nothing if the daemon was started externally (no PID file).
+ */
+export async function ensureStopped() {
+    if (!fs.existsSync(PID_FILE)) {
+        // No PID file = externally managed daemon. Don't touch it.
+        return;
+    }
+    let pid = null;
+    try {
+        const raw = fs.readFileSync(PID_FILE, "utf-8").trim();
+        const parsed = parseInt(raw, 10);
+        if (!isNaN(parsed) && parsed > 0)
+            pid = parsed;
+    }
+    catch {
+        // ignore
+    }
+    // Verify the PID actually points at an ollama process before SIGTERM.
+    // Prevents the classic PID-reuse bug where we'd kill a random process
+    // after a bot crash/restart left a stale pid file.
+    const pidIsOllama = pid ? await verifyPidIsOllama(pid) : false;
+    if (!pidIsOllama) {
+        console.log(`[ollama] pid file points to pid=${pid} which is no longer ollama — cleaning up`);
+        try {
+            fs.unlinkSync(PID_FILE);
+        }
+        catch { /* ignore */ }
+        persistManagedModel(null);
+        managedProcess = null;
+        managedModel = null;
+        return;
+    }
+    // Unload the model first so VRAM is freed even if the kill races.
+    // Model name might be in memory (current run) or on disk (survived a restart).
+    const modelToUnload = managedModel || loadManagedModelFromDisk();
+    if (modelToUnload) {
+        await unloadModel(modelToUnload);
+    }
+    try {
+        process.kill(pid, "SIGTERM");
+        console.log(`[ollama] stopped daemon pid=${pid}`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`[ollama] failed to kill pid=${pid}: ${msg}`);
+    }
+    // Clean up state
+    try {
+        fs.unlinkSync(PID_FILE);
+    }
+    catch { /* ignore */ }
+    persistManagedModel(null);
+    managedProcess = null;
+    managedModel = null;
+}
+/** Whether the current daemon was spawned by the bot (via PID file). */
+export function isBotManaged() {
+    return fs.existsSync(PID_FILE);
+}
+/** Currently loaded model name, if any. */
+export function getManagedModel() {
+    return managedModel || loadManagedModelFromDisk();
+}
+// ── Module-load side effects ──────────────────────────────────────────────
+//
+// On first import (bot startup), reconcile any stale pid file from a previous
+// crashed run AND restore the in-memory managedModel if the daemon is still
+// alive. Best-effort — failures are logged but not fatal.
+//
+// NOTE: SIGTERM/SIGINT handling lives in src/index.ts (the bot's shutdown()
+// function). That function calls ensureStopped() directly — we deliberately
+// do NOT install our own signal handler here, to avoid racing with the
+// bot's own cleanup path.
+void (async () => {
+    try {
+        await reconcileStalePidFile();
+        if (fs.existsSync(PID_FILE)) {
+            const diskModel = loadManagedModelFromDisk();
+            if (diskModel) {
+                managedModel = diskModel;
+                console.log(`[ollama] restored managed state from previous run (model=${diskModel})`);
+            }
+        }
+    }
+    catch (err) {
+        console.warn(`[ollama] startup reconciliation failed: ${err}`);
+    }
+})();

package/dist/services/personality.js

@@ -134,21 +134,27 @@ Always ask yourself first: "Can I solve this with my own intelligence?" If yes
  * @param isSDK Whether the active provider is the Claude SDK (has tool use)
  * @param language Preferred language ('de' or 'en')
  */
-export function buildSystemPrompt(isSDK, language = "de", chatId) {
-    const langInstruction = language === "en"
-        ? "Respond in English. If the user writes in another language, mirror their language naturally."
-        : "Reply in the language the user writes in. Match their language naturally.";
-    // Current date/time context
+export function buildSystemPrompt(isSDK, language = "en", chatId) {
+    // The deep base prompt has only de/en variants (writing four full
+    // personality templates is out of scope). For es/fr we fall back to
+    // the English base — the LLM mirrors the user's conversational language
+    // anyway via langInstruction below, so the base-prompt language is
+    // really just the "hint" for the system-prompt wrapper.
+    const deepLang = language === "de" ? "de" : "en";
+    const langInstruction = "Reply in the language the user writes in. Match their language naturally.";
+    // Current date/time context — locale formatting uses the user's picked
+    // locale for familiarity (German date formatting for de, etc.).
     const now = new Date();
-    const locale = language === "de" ? "de-DE" : "en-US";
-    const dateStr = now.toLocaleDateString(locale, { weekday: "long", year: "numeric", month: "long", day: "numeric" });
-    const timeStr = now.toLocaleTimeString(locale, { hour: "2-digit", minute: "2-digit" });
-    const timeContext = language === "de"
-        ? `Current date: ${dateStr}, ${timeStr} (Europe/Berlin).`
-        : `Current date: ${dateStr}, ${timeStr} (Europe/Berlin).`;
-    const parts = [getBasePrompt(language), langInstruction, timeContext];
+    const tzLocale = language === "de" ? "de-DE" :
+        language === "es" ? "es-ES" :
+            language === "fr" ? "fr-FR" :
+                "en-US";
+    const dateStr = now.toLocaleDateString(tzLocale, { weekday: "long", year: "numeric", month: "long", day: "numeric" });
+    const timeStr = now.toLocaleTimeString(tzLocale, { hour: "2-digit", minute: "2-digit" });
+    const timeContext = `Current date: ${dateStr}, ${timeStr} (Europe/Berlin).`;
+    const parts = [getBasePrompt(deepLang), langInstruction, timeContext];
     // Core self-awareness — always injected, adapted to active provider and language
-    parts.push(buildSelfAwareness(isSDK, getActiveProviderLabel(), language));
+    parts.push(buildSelfAwareness(isSDK, getActiveProviderLabel(), deepLang));
     if (soulContent) {
         parts.push(soulContent);
     }
@@ -186,7 +192,7 @@ export function buildSystemPrompt(isSDK, language = "de", chatId) {
  * Build a system prompt enhanced with semantically relevant memories.
  * Searches the vector index for context related to the user's message.
  */
-export async function buildSmartSystemPrompt(isSDK, language = "de", userMessage, chatId) {
+export async function buildSmartSystemPrompt(isSDK, language = "en", userMessage, chatId) {
     const base = buildSystemPrompt(isSDK, language, chatId);
     // SDK providers read memory directly via tools — skip
     if (isSDK || !userMessage)