@emqo/claudebridge 0.8.0 → 0.9.1

package/dist/core/agent.js

@@ -1,27 +1,42 @@
 import { spawn } from "child_process";
 import { mkdirSync } from "fs";
 import { join } from "path";
-import { UserLock } from "./lock.js";
+import { SessionLock } from "./lock.js";
 import { AccessControl } from "./permissions.js";
 import { EndpointRotator } from "./keys.js";
 import { generateSkillDoc } from "../skills/bridge.js";
+import { SessionManager } from "./session.js";
+import { SessionRouter } from "./router.js";
+import { log as rootLog } from "./logger.js";
+import { getProvider } from "../providers/registry.js";
+const log = rootLog.child("agent");
 export class AgentEngine {
     config;
     store;
     lock;
     rotator;
+    sessionMgr;
+    router;
+    sessionExpiryTimer;
     access;
     constructor(config, store) {
         this.config = config;
         this.store = store;
-        this.lock = new UserLock(config.redis.enabled ? config.redis.url : undefined);
+        this.lock = new SessionLock(config.redis.enabled ? config.redis.url : undefined);
         this.access = new AccessControl(config.access.allowed_users, config.access.allowed_groups);
         this.rotator = new EndpointRotator(config.endpoints);
+        this.sessionMgr = new SessionManager(store, config.agent.session);
+        this.router = new SessionRouter(this.sessionMgr, this.rotator, config.agent.session);
+        // Periodic idle session expiry (every 5 min)
+        this.sessionExpiryTimer = setInterval(() => {
+            this.sessionMgr.expireIdle();
+        }, 5 * 60 * 1000);
     }
     reloadConfig(config) {
         this.config = config;
         this.access.reload(config.access.allowed_users, config.access.allowed_groups);
         this.rotator.reload(config.endpoints);
+        // SessionManager/Router pick up config changes via reference
     }
     getEndpoints() {
         return this.rotator.list();
@@ -35,6 +50,12 @@ export class AgentEngine {
     getMaxParallel() {
         return this.config.agent.max_parallel || 1;
     }
+    getSessionManager() {
+        return this.sessionMgr;
+    }
+    getRouter() {
+        return this.router;
+    }
     getWorkDir(userId) {
         if (!this.config.workspace.isolation) {
             return this.config.agent.cwd || process.cwd();
@@ -43,290 +64,283 @@ export class AgentEngine {
         mkdirSync(dir, { recursive: true });
         return dir;
     }
+    /** @deprecated Use isSessionLocked() for multi-session mode */
     isLocked(userId) {
         return this.lock.isLocked(userId);
     }
-    async runStream(userId, prompt, platform, chatId, onChunk, overrideTimeoutMs) {
-        const release = await this.lock.acquire(userId);
+    isSessionLocked(subSessionId) {
+        return this.lock.isLocked(subSessionId);
+    }
+    isMultiSessionEnabled() {
+        return this.config.agent.session?.enabled !== false;
+    }
+    // ─── Multi-Session Entry Point ───────────────────────────────
+    /**
+     * Main entry point for user messages in multi-session mode.
+     * Routes to the correct sub-session and executes concurrently.
+     */
+    async handleUserMessage(userId, prompt, platform, chatId, replyToMsgId, onChunk, overrideTimeoutMs) {
+        // 1. Route
+        const decision = await this.router.route(userId, platform, chatId, prompt, replyToMsgId);
+        // 2. Create or get sub-session
+        let subSession;
+        if (decision.action === "create") {
+            if (!this.sessionMgr.canCreate(userId, platform)) {
+                // Evict the oldest idle session to make room
+                const active = this.sessionMgr.getActive(userId, platform);
+                const oldest = active.sort((a, b) => a.lastActiveAt - b.lastActiveAt)[0];
+                if (oldest) {
+                    this.sessionMgr.close(oldest.id);
+                    log.info("evicted oldest sub-session", { sessionId: oldest.id.slice(0, 8), userId });
+                }
+            }
+            subSession = this.sessionMgr.create(userId, platform, chatId, decision.label);
+            log.info("created sub-session", { sessionId: subSession.id.slice(0, 8), label: subSession.label, userId });
+        }
+        else {
+            subSession = this.sessionMgr.get(decision.subSessionId);
+            if (!subSession) {
+                // Safety fallback: session was closed/deleted between route and get
+                subSession = this.sessionMgr.create(userId, platform, chatId, prompt.slice(0, 50));
+                log.warn("routed session not found, created new", { sessionId: subSession.id.slice(0, 8), userId });
+            }
+        }
+        // 3. Execute in sub-session (per-session lock)
+        const res = await this._executeSubSession(subSession, prompt, platform, chatId, onChunk, overrideTimeoutMs);
+        // 4. Post-processing
+        this.store.addHistory(userId, platform, "user", prompt);
+        this.store.addHistory(userId, platform, "assistant", res.text);
+        this.store.recordUsage(userId, platform, res.cost || 0);
+        this.sessionMgr.touch(subSession.id);
+        this.sessionMgr.addCost(subSession.id, res.cost || 0);
+        // 5. Auto-label: set label on first message if empty
+        if (subSession.messageCount === 0 && !subSession.label) {
+            this.sessionMgr.updateLabel(subSession.id, prompt.slice(0, 50));
+            subSession.label = prompt.slice(0, 50);
+        }
+        // 6. Auto-summarize
+        if (this.config.agent.memory?.auto_summary)
+            this._autoSummarize(userId, prompt, res.text);
+        return { ...res, subSessionId: subSession.id, label: subSession.label };
+    }
+    /**
+     * Execute a prompt within a specific sub-session.
+     * Acquires per-session lock, resumes claude session via -r flag.
+     */
+    async _executeSubSession(subSession, prompt, platform, chatId, onChunk, overrideTimeoutMs) {
+        const release = await this.lock.acquire(subSession.id);
         try {
-            this.store.addHistory(userId, platform, "user", prompt);
-            const memories = this.config.agent.memory?.enabled ? this.store.getMemories(userId) : [];
+            const memories = this.config.agent.memory?.enabled ? this.store.getMemories(subSession.userId) : [];
             const memoryPrompt = memories.length ? memories.map(m => `- ${m.content}`).join("\n") : "";
-            const res = await this._executeWithRetry(userId, prompt, platform, chatId, onChunk, memoryPrompt, overrideTimeoutMs);
-            this.store.addHistory(userId, platform, "assistant", res.text);
-            this.store.recordUsage(userId, platform, res.cost || 0);
-            if (this.config.agent.memory?.auto_summary)
-                this._autoSummarize(userId, prompt, res.text);
-            return res;
+            const ep = this.rotator.count
+                ? this.rotator.next()
+                : { name: "default", provider: "claude", model: "" };
+            return await this._executeWithSession(subSession, prompt, platform, chatId, ep, onChunk, memoryPrompt, overrideTimeoutMs);
         }
         finally {
             release();
         }
     }
-    async runParallel(userId, prompt, platform, chatId, onChunk, overrideTimeoutMs) {
-        // No per-user lock — parallel tasks are independent
-        // No session resume — fresh session to prevent conflicts
-        const memories = this.config.agent.memory?.enabled ? this.store.getMemories(userId) : [];
-        const memoryPrompt = memories.length ? memories.map(m => `- ${m.content}`).join("\n") : "";
-        const maxRetries = Math.max(Math.min(this.rotator.count, 3), 1);
-        let lastErr;
-        for (let i = 0; i < maxRetries; i++) {
-            const ep = this.rotator.count
-                ? this.rotator.next()
-                : { name: "cli-default", api_key: "", base_url: "", model: "" };
-            try {
-                const res = await this._executeNoSession(userId, prompt, platform, chatId, ep, onChunk, memoryPrompt, overrideTimeoutMs);
-                this.store.recordUsage(userId, platform, res.cost || 0);
-                return res;
-            }
-            catch (err) {
-                lastErr = err;
-                const msg = String(err?.message || "");
-                if (msg.includes("429") || msg.includes("401") || msg.includes("529")) {
-                    console.warn(`[agent] endpoint ${ep.name} failed (parallel), rotating`);
-                    this.rotator.markFailed(ep);
-                    continue;
-                }
-                throw err;
-            }
+    /**
+     * Core execution: spawn claude CLI with session resume for a sub-session.
+     * Thin wrapper around _spawnAgent with sub-session persistence.
+     */
+    async _executeWithSession(subSession, prompt, platform, chatId, ep, onChunk, memoryPrompt, overrideTimeoutMs) {
+        try {
+            const res = await this._spawnAgent({
+                userId: subSession.userId, prompt, platform, chatId, ep, onChunk, memoryPrompt, overrideTimeoutMs,
+                resumeSessionId: subSession.claudeSessionId || undefined,
+                subSessionId: subSession.id,
+                subSessionLabel: subSession.label,
+                logLabel: `sub-session=${subSession.id.slice(0, 8)}`,
+            });
+            if (res.sessionId)
+                this.sessionMgr.setClaudeSessionId(subSession.id, res.sessionId);
+            return res;
+        }
+        catch (err) {
+            this.sessionMgr.setClaudeSessionId(subSession.id, "");
+            throw err;
         }
-        throw lastErr;
     }
-    async _executeWithRetry(userId, prompt, platform, chatId, onChunk, memoryPrompt, overrideTimeoutMs) {
-        const maxRetries = Math.max(Math.min(this.rotator.count, 3), 1);
-        let lastErr;
-        for (let i = 0; i < maxRetries; i++) {
-            const ep = this.rotator.count
-                ? this.rotator.next()
-                : { name: "cli-default", api_key: "", base_url: "", model: "" };
-            try {
-                return await this._execute(userId, prompt, platform, chatId, ep, onChunk, memoryPrompt, overrideTimeoutMs);
-            }
-            catch (err) {
-                lastErr = err;
-                const msg = String(err?.message || "");
-                if (msg.includes("429") || msg.includes("401") || msg.includes("529")) {
-                    console.warn(`[agent] endpoint ${ep.name} failed, rotating`);
-                    this.rotator.markFailed(ep);
-                    continue;
-                }
-                throw err;
-            }
+    // ─── Core Spawn Infrastructure ──────────────────────────────
+    /** Build the append system prompt (memories + skill doc) */
+    _buildAppendPrompt(opts) {
+        let appendPrompt = "";
+        if (opts.memoryPrompt)
+            appendPrompt += `User memories:\n${opts.memoryPrompt}\n\n`;
+        if (this.config.agent.skill?.enabled !== false) {
+            appendPrompt += generateSkillDoc({
+                userId: opts.userId, chatId: opts.chatId, platform: opts.platform,
+                locale: this.config.locale || "en",
+                ...(opts.subSessionId ? { subSessionId: opts.subSessionId, subSessionLabel: opts.subSessionLabel } : {}),
+            });
         }
-        throw lastErr;
+        return appendPrompt.trim();
     }
-    _execute(userId, prompt, platform, chatId, ep, onChunk, memoryPrompt, overrideTimeoutMs) {
+    /**
+     * Unified core: spawn provider CLI, parse stream, handle timeout.
+     * All execute methods delegate here.
+     */
+    _spawnAgent(opts) {
         return new Promise((resolve, reject) => {
-            const sessionId = this.store.getSession(userId) || "";
-            const cwd = this.getWorkDir(userId);
-            const args = ["-p", prompt, "--verbose", "--output-format", "stream-json", "--permission-mode", this.config.agent.permission_mode || "acceptEdits"];
-            if (ep.model)
-                args.push("--model", ep.model);
-            if (sessionId)
-                args.push("-r", sessionId);
-            if (this.config.agent.system_prompt)
-                args.push("--system-prompt", this.config.agent.system_prompt);
-            // Build combined append prompt: memories + skill doc
-            let appendPrompt = "";
-            if (memoryPrompt)
-                appendPrompt += `User memories:\n${memoryPrompt}\n\n`;
-            if (this.config.agent.skill?.enabled !== false) {
-                appendPrompt += generateSkillDoc({ userId, chatId, platform, locale: this.config.locale || "en" });
-            }
-            if (appendPrompt)
-                args.push("--append-system-prompt", appendPrompt.trim());
-            if (this.config.agent.allowed_tools?.length)
-                args.push("--allowed-tools", this.config.agent.allowed_tools.join(","));
-            if (this.config.agent.max_turns)
-                args.push("--max-turns", String(this.config.agent.max_turns));
-            if (this.config.agent.max_budget_usd)
-                args.push("--max-budget-usd", String(this.config.agent.max_budget_usd));
-            const env = { ...process.env };
-            if (ep.api_key)
-                env.ANTHROPIC_API_KEY = ep.api_key;
-            if (ep.base_url)
-                env.ANTHROPIC_BASE_URL = ep.base_url;
-            env.CLAUDEBRIDGE_DB = this.store.dbPath;
-            const child = spawn("claude", args, { cwd, env, stdio: ["pipe", "pipe", "pipe"] });
+            const provider = getProvider(opts.ep.provider || "claude");
+            const cwd = this.getWorkDir(opts.userId);
+            const label = opts.logLabel || "";
+            const verbose = opts.verbose !== false;
+            const appendPrompt = this._buildAppendPrompt(opts);
+            const args = provider.buildArgs({
+                prompt: opts.prompt,
+                model: opts.ep.model,
+                resumeSessionId: provider.supportsSessionResume ? opts.resumeSessionId : undefined,
+                systemPrompt: this.config.agent.system_prompt || undefined,
+                appendSystemPrompt: appendPrompt || undefined,
+                allowedTools: this.config.agent.allowed_tools,
+                maxTurns: this.config.agent.max_turns,
+                maxBudgetUsd: this.config.agent.max_budget_usd,
+                permissionMode: this.config.agent.permission_mode || "acceptEdits",
+            });
+            const env = provider.buildEnv({ CLAUDEBRIDGE_DB: this.store.dbPath });
+            const child = spawn(provider.binary, args, { cwd, env, stdio: ["pipe", "pipe", "pipe"] });
             child.stdin.end();
-            console.log(`[agent] spawned claude pid=${child.pid} cwd=${cwd} args=${args.join(" ")}`);
-            const timeoutMs = overrideTimeoutMs !== undefined ? overrideTimeoutMs : (this.config.agent.timeout_seconds || 600) * 1000;
+            log.info("spawned agent", { provider: opts.ep.provider || "claude", pid: child.pid, label, cwd });
+            const timeoutMs = opts.overrideTimeoutMs !== undefined
+                ? opts.overrideTimeoutMs
+                : (this.config.agent.timeout_seconds || 600) * 1000;
             const timer = timeoutMs > 0 ? setTimeout(() => { try {
                 child.kill("SIGTERM");
             }
             catch { } }, timeoutMs) : null;
             let fullText = "";
-            let newSessionId = sessionId;
+            let sessionId = opts.resumeSessionId || "";
             let cost = 0;
             let buffer = "";
             child.stdout.on("data", (data) => {
                 const chunk = data.toString();
-                console.log(`[agent] stdout chunk: ${chunk.slice(0, 200)}`);
+                if (verbose)
+                    log.debug("stdout chunk", { data: chunk.slice(0, 200) });
                 buffer += chunk;
                 const lines = buffer.split("\n");
                 buffer = lines.pop() || "";
                 for (const line of lines) {
                     if (!line.trim())
                         continue;
-                    try {
-                        const msg = JSON.parse(line);
-                        if (msg.type === "system" && msg.subtype === "init" && msg.session_id) {
-                            newSessionId = msg.session_id;
-                        }
-                        if (msg.type === "assistant" && msg.message?.content) {
-                            for (const block of msg.message.content) {
-                                if (block.type === "text" && block.text) {
-                                    fullText += block.text + "\n";
-                                    if (onChunk)
-                                        onChunk(block.text, fullText);
-                                }
-                            }
-                        }
-                        if (msg.type === "result") {
-                            if (msg.result)
-                                fullText = msg.result;
-                            if (msg.total_cost_usd)
-                                cost = msg.total_cost_usd;
-                            if (msg.is_error) {
-                                console.error(`[agent] claude error result: subtype=${msg.subtype} message=${JSON.stringify(msg.error_message || msg.message || "unknown").slice(0, 500)}`);
+                    const event = provider.parseLine(line);
+                    switch (event.type) {
+                        case "session_init":
+                            if (event.sessionId)
+                                sessionId = event.sessionId;
+                            break;
+                        case "text_chunk":
+                            if (event.text) {
+                                fullText += event.text + "\n";
+                                if (opts.onChunk)
+                                    opts.onChunk(event.text, fullText);
                             }
-                        }
+                            break;
+                        case "result":
+                            if (event.text)
+                                fullText = event.text;
+                            if (event.cost)
+                                cost = event.cost;
+                            if (verbose && event.isError)
+                                log.error("agent error result", { label });
+                            break;
                     }
-                    catch { }
                 }
             });
             let stderr = "";
             child.stderr.on("data", (data) => {
                 const s = data.toString();
                 stderr += s;
-                console.log(`[agent] stderr: ${s.slice(0, 200)}`);
+                if (verbose)
+                    log.debug("stderr", { data: s.slice(0, 200) });
             });
             child.on("close", (code, signal) => {
                 if (timer)
                     clearTimeout(timer);
-                console.log(`[agent] claude exited code=${code} signal=${signal} fullText=${fullText.length}chars stderr=${stderr.slice(0, 200)}`);
+                log.info("agent exited", { code, signal, label, textLen: fullText.length });
                 if (signal === "SIGTERM") {
-                    console.warn(`[agent] claude timed out after ${timeoutMs / 1000}s`);
-                    if (newSessionId)
-                        this.store.setSession(userId, newSessionId, platform);
-                    resolve({ text: fullText.trim() || "(timed out)", sessionId: newSessionId, cost, timedOut: true });
+                    log.warn("agent timed out", { seconds: timeoutMs / 1000 });
+                    resolve({ text: fullText.trim() || "(timed out)", sessionId, cost, timedOut: true });
                     return;
                 }
                 if (code === 0 || fullText.trim()) {
-                    if (newSessionId)
-                        this.store.setSession(userId, newSessionId, platform);
-                    resolve({ text: fullText.trim() || "(no response)", sessionId: newSessionId, cost });
+                    resolve({ text: fullText.trim() || "(no response)", sessionId, cost });
                 }
                 else {
-                    // Don't save session on failure — stale session would lock the user in a failure loop
-                    this.store.clearSession(userId);
-                    reject(new Error(`claude exited ${code}: ${stderr.slice(0, 500)}`));
+                    reject(new Error(`agent exited ${code}: ${stderr.slice(0, 500)}`));
                 }
             });
             child.on("error", reject);
         });
     }
-    _executeNoSession(userId, prompt, platform, chatId, ep, onChunk, memoryPrompt, overrideTimeoutMs) {
-        return new Promise((resolve, reject) => {
-            const cwd = this.getWorkDir(userId);
-            const args = ["-p", prompt, "--verbose", "--output-format", "stream-json", "--permission-mode", this.config.agent.permission_mode || "acceptEdits"];
-            if (ep.model)
-                args.push("--model", ep.model);
-            // No session resume — fresh session for parallel execution
-            if (this.config.agent.system_prompt)
-                args.push("--system-prompt", this.config.agent.system_prompt);
-            let appendPrompt = "";
-            if (memoryPrompt)
-                appendPrompt += `User memories:\n${memoryPrompt}\n\n`;
-            if (this.config.agent.skill?.enabled !== false) {
-                appendPrompt += generateSkillDoc({ userId, chatId, platform, locale: this.config.locale || "en" });
-            }
-            if (appendPrompt)
-                args.push("--append-system-prompt", appendPrompt.trim());
-            if (this.config.agent.allowed_tools?.length)
-                args.push("--allowed-tools", this.config.agent.allowed_tools.join(","));
-            if (this.config.agent.max_turns)
-                args.push("--max-turns", String(this.config.agent.max_turns));
-            if (this.config.agent.max_budget_usd)
-                args.push("--max-budget-usd", String(this.config.agent.max_budget_usd));
-            const env = { ...process.env };
-            if (ep.api_key)
-                env.ANTHROPIC_API_KEY = ep.api_key;
-            if (ep.base_url)
-                env.ANTHROPIC_BASE_URL = ep.base_url;
-            env.CLAUDEBRIDGE_DB = this.store.dbPath;
-            const child = spawn("claude", args, { cwd, env, stdio: ["pipe", "pipe", "pipe"] });
-            child.stdin.end();
-            console.log(`[agent] spawned claude (parallel) pid=${child.pid} cwd=${cwd}`);
-            const timeoutMs = overrideTimeoutMs !== undefined ? overrideTimeoutMs : (this.config.agent.timeout_seconds || 600) * 1000;
-            const timer = timeoutMs > 0 ? setTimeout(() => { try {
-                child.kill("SIGTERM");
-            }
-            catch { } }, timeoutMs) : null;
-            let fullText = "";
-            let sessionId = "";
-            let cost = 0;
-            let buffer = "";
-            child.stdout.on("data", (data) => {
-                buffer += data.toString();
-                const lines = buffer.split("\n");
-                buffer = lines.pop() || "";
-                for (const line of lines) {
-                    if (!line.trim())
-                        continue;
-                    try {
-                        const msg = JSON.parse(line);
-                        if (msg.type === "system" && msg.subtype === "init" && msg.session_id) {
-                            sessionId = msg.session_id;
-                        }
-                        if (msg.type === "assistant" && msg.message?.content) {
-                            for (const block of msg.message.content) {
-                                if (block.type === "text" && block.text) {
-                                    fullText += block.text + "\n";
-                                    if (onChunk)
-                                        onChunk(block.text, fullText);
-                                }
-                            }
-                        }
-                        if (msg.type === "result") {
-                            if (msg.result)
-                                fullText = msg.result;
-                            if (msg.total_cost_usd)
-                                cost = msg.total_cost_usd;
-                        }
-                    }
-                    catch { }
-                }
-            });
-            let stderr = "";
-            child.stderr.on("data", (data) => { stderr += data.toString(); });
-            child.on("close", (code, signal) => {
-                if (timer)
-                    clearTimeout(timer);
-                console.log(`[agent] claude (parallel) exited code=${code} signal=${signal} text=${fullText.length}chars`);
-                if (signal === "SIGTERM") {
-                    console.warn(`[agent] claude (parallel) timed out after ${timeoutMs / 1000}s`);
-                    resolve({ text: fullText.trim() || "(timed out)", sessionId, cost, timedOut: true });
-                }
-                else if (code === 0 || fullText.trim()) {
-                    resolve({ text: fullText.trim() || "(no response)", sessionId, cost });
-                }
-                else {
-                    reject(new Error(`claude exited ${code}: ${stderr.slice(0, 500)}`));
-                }
+    // ─── Legacy Single-Session Entry Points ──────────────────────
+    /** @deprecated Use handleUserMessage() for multi-session mode */
+    async runStream(userId, prompt, platform, chatId, onChunk, overrideTimeoutMs) {
+        const release = await this.lock.acquire(userId);
+        try {
+            this.store.addHistory(userId, platform, "user", prompt);
+            const memories = this.config.agent.memory?.enabled ? this.store.getMemories(userId) : [];
+            const memoryPrompt = memories.length ? memories.map(m => `- ${m.content}`).join("\n") : "";
+            const res = await this._executeWithRetry(userId, prompt, platform, chatId, onChunk, memoryPrompt, overrideTimeoutMs);
+            this.store.addHistory(userId, platform, "assistant", res.text);
+            this.store.recordUsage(userId, platform, res.cost || 0);
+            if (this.config.agent.memory?.auto_summary)
+                this._autoSummarize(userId, prompt, res.text);
+            return res;
+        }
+        finally {
+            release();
+        }
+    }
+    async runParallel(userId, prompt, platform, chatId, onChunk, overrideTimeoutMs) {
+        // No per-user lock — parallel tasks are independent
+        // No session resume — fresh session to prevent conflicts
+        const memories = this.config.agent.memory?.enabled ? this.store.getMemories(userId) : [];
+        const memoryPrompt = memories.length ? memories.map(m => `- ${m.content}`).join("\n") : "";
+        const ep = this.rotator.count
+            ? this.rotator.next()
+            : { name: "default", provider: "claude", model: "" };
+        const res = await this._executeNoSession(userId, prompt, platform, chatId, ep, onChunk, memoryPrompt, overrideTimeoutMs);
+        this.store.recordUsage(userId, platform, res.cost || 0);
+        return res;
+    }
+    async _executeWithRetry(userId, prompt, platform, chatId, onChunk, memoryPrompt, overrideTimeoutMs) {
+        const ep = this.rotator.count
+            ? this.rotator.next()
+            : { name: "default", provider: "claude", model: "" };
+        return await this._execute(userId, prompt, platform, chatId, ep, onChunk, memoryPrompt, overrideTimeoutMs);
+    }
+    /** Legacy single-session execution. Thin wrapper around _spawnAgent with store persistence. */
+    async _execute(userId, prompt, platform, chatId, ep, onChunk, memoryPrompt, overrideTimeoutMs) {
+        const resumeSessionId = this.store.getSession(userId) || undefined;
+        try {
+            const res = await this._spawnAgent({
+                userId, prompt, platform, chatId, ep, onChunk, memoryPrompt, overrideTimeoutMs,
+                resumeSessionId, logLabel: `legacy user=${userId}`,
             });
-            child.on("error", reject);
+            if (res.sessionId)
+                this.store.setSession(userId, res.sessionId, platform);
+            return res;
+        }
+        catch (err) {
+            this.store.clearSession(userId);
+            throw err;
+        }
+    }
+    /** Parallel execution without session resume. Thin wrapper around _spawnAgent. */
+    _executeNoSession(userId, prompt, platform, chatId, ep, onChunk, memoryPrompt, overrideTimeoutMs) {
+        return this._spawnAgent({
+            userId, prompt, platform, chatId, ep, onChunk, memoryPrompt, overrideTimeoutMs,
+            logLabel: "parallel", verbose: false,
         });
     }
     _autoSummarize(userId, prompt, response) {
         const ep = this.rotator.count
             ? this.rotator.next()
-            : { name: "cli-default", api_key: "", base_url: "", model: "" };
+            : { name: "default", provider: "claude", model: "" };
         const env = { ...process.env };
-        if (ep.api_key)
-            env.ANTHROPIC_API_KEY = ep.api_key;
-        if (ep.base_url)
-            env.ANTHROPIC_BASE_URL = ep.base_url;
         const summaryPrompt = `Extract 1-3 key facts worth remembering about the user from this exchange. Output only bullet points, no preamble. If nothing worth remembering, output "NONE".\n\nUser: ${prompt.slice(0, 500)}\nAssistant: ${response.slice(0, 1000)}`;
         const args = ["-p", summaryPrompt, "--verbose", "--output-format", "stream-json", "--max-turns", "1", "--max-budget-usd", "0.05"];
         if (ep.model)
@@ -337,7 +351,7 @@ export class AgentEngine {
             child.kill("SIGTERM");
         }
         catch { } }, 60000);
-        console.log(`[agent] auto-summary spawned pid=${child.pid} for ${userId}`);
+        log.info("auto-summary spawned", { pid: child.pid, userId });
         let result = "";
         let cost = 0;
         let buffer = "";
@@ -365,24 +379,24 @@ export class AgentEngine {
         child.on("close", (code) => {
             clearTimeout(killTimer);
             if (code !== 0) {
-                console.warn(`[agent] auto-summary failed code=${code} stderr=${stderr.slice(0, 200)} for ${userId}`);
+                log.warn("auto-summary failed", { code, stderr: stderr.slice(0, 200), userId });
             }
             if (cost > 0) {
                 this.store.recordUsage(userId, "auto-summary", cost);
-                console.log(`[agent] auto-summary cost=$${cost.toFixed(4)} for ${userId}`);
+                log.info("auto-summary cost", { cost: cost.toFixed(4), userId });
             }
             if (result && !result.includes("NONE")) {
                 const saved = this.store.addMemory(userId, result.trim(), "auto");
                 this.store.trimMemories(userId, this.config.agent.memory?.max_memories || 50);
                 if (saved)
-                    console.log(`[agent] auto-summary saved for ${userId}`);
+                    log.info("auto-summary saved", { userId });
                 else
-                    console.log(`[agent] auto-summary skipped (duplicate) for ${userId}`);
+                    log.info("auto-summary skipped (duplicate)", { userId });
             }
             else {
-                console.log(`[agent] auto-summary result=NONE for ${userId}`);
+                log.info("auto-summary result=NONE", { userId });
             }
         });
-        child.on("error", (err) => { console.warn(`[agent] auto-summary spawn error: ${err.message}`); });
+        child.on("error", (err) => { log.warn("auto-summary spawn error", { error: err.message }); });
     }
 }