@emqo/claudebridge 0.8.0 → 0.9.1

package/config.yaml.example

@@ -1,12 +1,15 @@
 # Leave endpoints empty to use claude CLI's own authentication
 # 留空则直接使用 claude CLI 自身的认证配置
 endpoints: []
-#  - name: "default"
-#    base_url: ""
-#    api_key: "sk-your-api-key"
+#  - name: "claude-main"
+#    provider: "claude"
 #    model: "claude-sonnet-4-20250514"
+#  - name: "codex"
+#    provider: "codex"
+#    model: "o3-mini"
 
 locale: en  # "zh" for Chinese
+log_level: info  # debug | info | warn | error
 
 agent:
   allowed_tools:
@@ -30,6 +33,12 @@ agent:
     max_memories: 50
   skill:
     enabled: true
+  session:
+    enabled: true             # Enable multi-session (concurrent conversations per user)
+    max_per_user: 3           # Max concurrent sub-sessions per user
+    idle_timeout_minutes: 30  # Auto-close idle sub-sessions after this time
+    classifier_budget: 0.05   # Max budget for routing classifier (Tier 3)
+    classifier_model: ""      # Model for classifier (empty = use default)
 
 workspace:
   base_dir: "./workspaces"

package/dist/adapters/discord.d.ts

@@ -17,6 +17,8 @@ export declare class DiscordAdapter implements Adapter {
     reloadConfig(config: DiscordConfig, locale: string): void;
     private setup;
     private handlePrompt;
+    /** Chunk text and send via edit + follow-up replies */
+    private sendChunkedResponse;
     start(): Promise<void>;
     stop(): void;
     private checkReminders;
@@ -24,4 +26,5 @@ export declare class DiscordAdapter implements Adapter {
     private runAutoTask;
     private checkApprovals;
     private handleStatusCommand;
+    private handleSessionsCommand;
 }

package/dist/adapters/discord.js

@@ -4,6 +4,8 @@ import { join } from "path";
 import { chunkText } from "./base.js";
 import { reloadConfig } from "../core/config.js";
 import { t } from "../core/i18n.js";
+import { log as rootLog } from "../core/logger.js";
+const log = rootLog.child("discord");
 const EDIT_INTERVAL = 1500;
 export class DiscordAdapter {
     engine;
@@ -48,12 +50,17 @@ export class DiscordAdapter {
             if (!this.engine.access.isAllowed(msg.author.id, groupId))
                 return;
             const text = msg.content.replace(/<@!?\d+>/g, "").trim();
+            // Extract reply-to message ID for session routing
+            const replyToMsgId = msg.reference?.messageId || undefined;
             // Management commands
             if (text === "!help") {
                 await msg.reply(t(this.locale, "help").replaceAll("/", "!"));
                 return;
             }
             if (text === "!new") {
+                if (this.engine.isMultiSessionEnabled()) {
+                    this.engine.getSessionManager().closeAll(msg.author.id);
+                }
                 this.store.clearSession(msg.author.id);
                 await msg.reply(t(this.locale, "session_cleared"));
                 return;
@@ -129,6 +136,10 @@ export class DiscordAdapter {
                 await this.handleStatusCommand(msg);
                 return;
             }
+            if (text === "!sessions") {
+                await this.handleSessionsCommand(msg);
+                return;
+            }
             // File upload handling
             if (msg.attachments.size > 0) {
                 const ws = this.engine.getWorkDir(msg.author.id);
@@ -142,16 +153,55 @@ export class DiscordAdapter {
                 }
                 const names = [...msg.attachments.values()].map(a => a.name).join(", ");
                 const prompt = text || `Analyze the uploaded file(s): ${names}`;
-                await this.handlePrompt(msg, prompt);
+                await this.handlePrompt(msg, prompt, replyToMsgId);
                 return;
             }
             // Text message — send to Claude (skill system handles intents)
             if (!text)
                 return;
-            await this.handlePrompt(msg, text);
+            await this.handlePrompt(msg, text, replyToMsgId);
         });
     }
-    async handlePrompt(msg, text) {
+    async handlePrompt(msg, text, replyToMsgId) {
+        // Multi-session mode: route and execute concurrently
+        if (this.engine.isMultiSessionEnabled()) {
+            const placeholder = await msg.reply(t(this.locale, "thinking"));
+            let lastEdit = 0;
+            let lastText = "";
+            try {
+                const res = await this.engine.handleUserMessage(msg.author.id, text, "discord", String(msg.channelId), replyToMsgId, async (_chunk, full) => {
+                    const now = Date.now();
+                    if (now - lastEdit < EDIT_INTERVAL)
+                        return;
+                    const preview = full.slice(-1900) + "\n\n...";
+                    if (preview === lastText)
+                        return;
+                    lastText = preview;
+                    lastEdit = now;
+                    try {
+                        await placeholder.edit(preview);
+                    }
+                    catch { }
+                });
+                // Track response message for reply-to routing
+                if (res.subSessionId) {
+                    this.engine.getSessionManager().trackMessage(placeholder.id, String(msg.channelId), res.subSessionId);
+                }
+                // Add label prefix if multiple active sessions
+                const activeSessions = this.engine.getSessionManager().getActive(msg.author.id, "discord");
+                const labelPrefix = activeSessions.length > 1 && res.label ? `[${res.label.slice(0, 30)}]\n` : "";
+                await this.sendChunkedResponse(msg, placeholder, res.text, labelPrefix);
+            }
+            catch (err) {
+                log.error("error", { error: err?.message });
+                try {
+                    await placeholder.edit(`Error: ${err.message || "unknown"}`);
+                }
+                catch { }
+            }
+            return;
+        }
+        // Legacy single-session mode
         if (this.engine.isLocked(msg.author.id)) {
             await msg.reply(t(this.locale, "still_processing"));
             return;
@@ -174,30 +224,34 @@ export class DiscordAdapter {
                 }
                 catch { }
             });
-            const maxLen = this.config.chunk_size || 1900;
-            const chunks = chunkText(res.text, maxLen);
-            try {
-                await placeholder.edit(chunks[0]);
-            }
-            catch { }
-            for (let i = 1; i < chunks.length; i++) {
-                await msg.reply(chunks[i]);
-            }
+            await this.sendChunkedResponse(msg, placeholder, res.text);
         }
         catch (err) {
-            console.error("[discord] error:", err);
+            log.error("error", { error: err?.message });
             try {
                 await placeholder.edit(`Error: ${err.message || "unknown"}`);
             }
             catch { }
         }
     }
+    /** Chunk text and send via edit + follow-up replies */
+    async sendChunkedResponse(msg, placeholder, text, labelPrefix = "") {
+        const maxLen = this.config.chunk_size || 1900;
+        const chunks = chunkText(labelPrefix + text, maxLen);
+        try {
+            await placeholder.edit(chunks[0]);
+        }
+        catch { }
+        for (let i = 1; i < chunks.length; i++) {
+            await msg.reply(chunks[i]);
+        }
+    }
     async start() {
-        console.log("[discord] starting bot...");
+        log.info("starting bot...");
         await this.client.login(this.config.token);
-        console.log(`[discord] logged in as ${this.client.user?.tag}`);
+        log.info("logged in", { tag: this.client.user?.tag });
         this.maxParallel = this.engine.getMaxParallel();
-        console.log(`[discord] max_parallel=${this.maxParallel}`);
+        log.info("ready", { maxParallel: this.maxParallel, multiSession: this.engine.isMultiSessionEnabled() });
         this.reminderTimer = setInterval(() => this.checkReminders(), 30000);
         this.autoTimer = setInterval(() => this.processAutoTasks(), 60000);
         this.approvalTimer = setInterval(() => this.checkApprovals(), 15000);
@@ -222,7 +276,7 @@ export class DiscordAdapter {
             }
         }
         catch (e) {
-            console.error("[discord] reminder error:", e);
+            log.error("reminder error", { error: e?.message });
         }
     }
     async processAutoTasks() {
@@ -243,7 +297,7 @@ export class DiscordAdapter {
                 throw new Error("channel not found");
             const channel = ch;
             await channel.send(t(this.locale, "auto_starting", { id: task.id, desc: task.description }));
-            console.log(`[discord] auto-task #${task.id} for ${task.user_id}`);
+            log.info("auto-task starting", { taskId: task.id, userId: task.user_id });
             // Always use runParallel for auto-tasks: fresh session, no user session pollution
             const res = await this.engine.runParallel(task.user_id, task.description, "discord", task.chat_id, undefined, 0);
             if (res.timedOut) {
@@ -278,7 +332,7 @@ export class DiscordAdapter {
         }
         catch (err) {
             this.store.markTaskResult(task.id, "failed");
-            console.error(`[discord] auto-task #${task.id} failed:`, err);
+            log.error("auto-task failed", { taskId: task.id, error: err?.message });
             // Self-healing: auto-retry failed tasks (max 3 retries)
             const retryMatch = task.description.match(/\[retry (\d+)\/3\]/);
             const retryCount = retryMatch ? parseInt(retryMatch[1]) : 0;
@@ -310,7 +364,7 @@ export class DiscordAdapter {
             }
         }
         catch (e) {
-            console.error("[discord] approval check error:", e);
+            log.error("approval check error", { error: e?.message });
         }
     }
     async handleStatusCommand(msg) {
@@ -337,4 +391,22 @@ export class DiscordAdapter {
         const report = `${t(this.locale, "status_report")}\n${lines.join("\n")}\n\nSummary: ${summary}`;
         await msg.reply(report);
     }
+    async handleSessionsCommand(msg) {
+        if (!this.engine.isMultiSessionEnabled()) {
+            await msg.reply("Multi-session mode is disabled.");
+            return;
+        }
+        const sessions = this.engine.getSessionManager().getActive(msg.author.id, "discord");
+        if (!sessions.length) {
+            await msg.reply(t(this.locale, "no_sessions"));
+            return;
+        }
+        const statusIcon = { active: "🟢", idle: "🟡", expired: "🔴", closed: "⚫" };
+        const lines = sessions.map(s => {
+            const ago = Math.round((Date.now() - s.lastActiveAt) / 60000);
+            const locked = this.engine.isSessionLocked(s.id) ? " [processing]" : "";
+            return `${statusIcon[s.status] || "⚪"} ${s.id.slice(0, 8)} "${s.label || "(no topic)"}" (${ago}min ago, ${s.messageCount} msgs, $${s.totalCost.toFixed(4)})${locked}`;
+        });
+        await msg.reply(`${t(this.locale, "sessions_list")}\n${lines.join("\n")}`);
+    }
 }

package/dist/adapters/telegram.d.ts

@@ -26,6 +26,8 @@ export declare class TelegramAdapter implements Adapter {
     private pageKeyboard;
     private handlePageCallback;
     private handlePrompt;
+    /** Format and send a response with MarkdownV2 + pagination support */
+    private sendFormattedResponse;
     start(): Promise<void>;
     stop(): void;
     private registerCommands;
@@ -35,4 +37,5 @@ export declare class TelegramAdapter implements Adapter {
     private checkApprovals;
     private handleApprovalCallback;
     private handleStatusCommand;
+    private handleSessionsCommand;
 }

package/dist/adapters/telegram.js

@@ -2,6 +2,8 @@ import { chunkText } from "./base.js";
 import { reloadConfig } from "../core/config.js";
 import { toTelegramMarkdown } from "../core/markdown.js";
 import { t, getCommandDescriptions } from "../core/i18n.js";
+import { log as rootLog } from "../core/logger.js";
+const log = rootLog.child("telegram");
 const EDIT_INTERVAL = 1500;
 export class TelegramAdapter {
     engine;
@@ -45,7 +47,7 @@ export class TelegramAdapter {
                 clearTimeout(timer);
                 const json = await res.json();
                 if (!json.ok) {
-                    console.error(`[telegram] API error ${method}:`, json.description || json);
+                    log.error("API error", { method, description: json.description });
                     const err = new Error(json.description || `Telegram API error: ${method}`);
                     err.apiError = true;
                     throw err;
@@ -59,11 +61,12 @@ export class TelegramAdapter {
             }
         }
     }
-    async reply(chatId, text, parseMode) {
+    async reply(chatId, text, parseMode, replyToMsgId) {
         return this.call("sendMessage", {
             chat_id: chatId,
             text,
             ...(parseMode ? { parse_mode: parseMode } : {}),
+            ...(replyToMsgId ? { reply_to_message_id: replyToMsgId } : {}),
         });
     }
     async editMsg(chatId, msgId, text, parseMode) {
@@ -97,17 +100,24 @@ export class TelegramAdapter {
             return;
         const groupId = msg.chat.type !== "private" ? String(chatId) : undefined;
         if (!this.engine.access.isAllowed(String(uid), groupId)) {
-            console.log(`[telegram] user ${uid} not allowed`);
+            log.info("user not allowed", { uid });
             return;
         }
         const text = (msg.text || "").trim();
-        console.log(`[telegram] ${uid}: ${text.slice(0, 50)}`);
+        log.debug("message", { uid, text: text.slice(0, 50) });
+        // Extract reply-to message ID for session routing
+        const replyToMsgId = msg.reply_to_message?.message_id
+            ? String(msg.reply_to_message.message_id)
+            : undefined;
         // Management commands
         if (text === "/start" || text === "/help") {
             await this.reply(chatId, t(this.locale, "help"));
             return;
         }
         if (text === "/new") {
+            if (this.engine.isMultiSessionEnabled()) {
+                this.engine.getSessionManager().closeAll(String(uid));
+            }
             this.store.clearSession(String(uid));
             await this.reply(chatId, t(this.locale, "session_cleared"));
             return;
@@ -157,6 +167,10 @@ export class TelegramAdapter {
             await this.handleStatusCommand(chatId, String(uid));
             return;
         }
+        if (text === "/sessions") {
+            await this.handleSessionsCommand(chatId, String(uid));
+            return;
+        }
         // File upload
         if (msg.document || msg.photo) {
             let fileId;
@@ -180,7 +194,7 @@ export class TelegramAdapter {
                 const ws = this.engine.getWorkDir(String(uid));
                 writeFileSync(join(ws, fileName), buf);
                 const prompt = msg.caption || `Analyze the uploaded file: ${fileName}`;
-                await this.handlePrompt(chatId, String(uid), prompt);
+                await this.handlePrompt(chatId, String(uid), prompt, replyToMsgId);
             }
             catch (e) {
                 await this.reply(chatId, t(this.locale, "upload_failed") + e.message);
@@ -189,7 +203,7 @@ export class TelegramAdapter {
         }
         // Text message — send to Claude (skill system handles intents)
         if (text)
-            await this.handlePrompt(chatId, String(uid), text);
+            await this.handlePrompt(chatId, String(uid), text, replyToMsgId);
     }
     pageKeyboard(chatId, msgId, cur, total) {
         const btns = [];
@@ -256,7 +270,39 @@ export class TelegramAdapter {
         }
         await answer();
     }
-    async handlePrompt(chatId, uid, text) {
+    async handlePrompt(chatId, uid, text, replyToMsgId) {
+        // Multi-session mode: route and execute concurrently (no global lock check)
+        if (this.engine.isMultiSessionEnabled()) {
+            const placeholder = await this.reply(chatId, t(this.locale, "thinking"));
+            const msgId = placeholder.message_id;
+            let lastEdit = 0;
+            try {
+                log.info("running claude (multi-session)", { uid });
+                const res = await this.engine.handleUserMessage(uid, text, "telegram", String(chatId), replyToMsgId, async (_chunk, full) => {
+                    const now = Date.now();
+                    if (now - lastEdit < EDIT_INTERVAL)
+                        return;
+                    lastEdit = now;
+                    const preview = full.slice(-3500) + "\n\n...";
+                    await this.editMsg(chatId, msgId, preview);
+                });
+                log.info("claude done", { uid, session: res.subSessionId?.slice(0, 8), cost: res.cost?.toFixed(4) });
+                // Track response message → sub-session mapping for future reply-to routing
+                if (res.subSessionId) {
+                    this.engine.getSessionManager().trackMessage(String(msgId), String(chatId), res.subSessionId);
+                }
+                // Check if user has multiple active sessions — add label prefix
+                const activeSessions = this.engine.getSessionManager().getActive(uid, "telegram");
+                const labelPrefix = activeSessions.length > 1 && res.label ? `[${res.label.slice(0, 30)}]\n` : "";
+                await this.sendFormattedResponse(chatId, msgId, res.text, labelPrefix);
+            }
+            catch (err) {
+                log.error("claude error", { error: err?.message });
+                await this.editMsg(chatId, msgId, `Error: ${err.message || "unknown"}`);
+            }
+            return;
+        }
+        // Legacy single-session mode (session.enabled: false)
         if (this.engine.isLocked(uid)) {
             await this.reply(chatId, t(this.locale, "still_processing"));
             return;
@@ -265,7 +311,7 @@ export class TelegramAdapter {
         const msgId = placeholder.message_id;
         let lastEdit = 0;
         try {
-            console.log(`[telegram] running claude for ${uid}...`);
+            log.info("running claude", { uid });
             const res = await this.engine.runStream(uid, text, "telegram", String(chatId), async (_chunk, full) => {
                 const now = Date.now();
                 if (now - lastEdit < EDIT_INTERVAL)
@@ -274,63 +320,64 @@ export class TelegramAdapter {
                 const preview = full.slice(-3500) + "\n\n...";
                 await this.editMsg(chatId, msgId, preview);
             });
-            console.log(`[telegram] claude done for ${uid}, cost=$${res.cost?.toFixed(4)}`);
-            const maxLen = this.config.chunk_size || 4000;
-            const md = toTelegramMarkdown(res.text);
-            const mdChunks = chunkText(md, maxLen);
-            const rawChunks = chunkText(res.text, maxLen);
-            if (mdChunks.length <= 1) {
-                // Single page — no pagination needed
-                try {
-                    await this.editMsg(chatId, msgId, mdChunks[0], "MarkdownV2");
-                }
-                catch {
-                    await this.editMsg(chatId, msgId, res.text);
-                }
+            log.info("claude done", { uid, cost: res.cost?.toFixed(4) });
+            await this.sendFormattedResponse(chatId, msgId, res.text);
+        }
+        catch (err) {
+            log.error("claude error", { error: err?.message });
+            await this.editMsg(chatId, msgId, `Error: ${err.message || "unknown"}`);
+        }
+    }
+    /** Format and send a response with MarkdownV2 + pagination support */
+    async sendFormattedResponse(chatId, msgId, text, labelPrefix = "") {
+        const maxLen = this.config.chunk_size || 4000;
+        const fullText = labelPrefix + text;
+        const md = toTelegramMarkdown(fullText);
+        const mdChunks = chunkText(md, maxLen);
+        const rawChunks = chunkText(fullText, maxLen);
+        if (mdChunks.length <= 1) {
+            try {
+                await this.editMsg(chatId, msgId, mdChunks[0], "MarkdownV2");
             }
-            else {
-                // Multi-page — store pages and show inline keyboard
-                const key = `${chatId}:${msgId}`;
-                // Evict oldest if too many pages cached
-                if (this.pages.size >= 50) {
-                    const oldest = this.pages.keys().next().value;
-                    this.pages.delete(oldest);
-                }
-                this.pages.set(key, { chunks: mdChunks, raw: rawChunks, ts: Date.now() });
-                setTimeout(() => this.pages.delete(key), TelegramAdapter.PAGE_TTL);
-                const keyboard = this.pageKeyboard(chatId, msgId, 0, mdChunks.length);
+            catch {
+                await this.editMsg(chatId, msgId, fullText);
+            }
+        }
+        else {
+            const key = `${chatId}:${msgId}`;
+            if (this.pages.size >= 50) {
+                const oldest = this.pages.keys().next().value;
+                this.pages.delete(oldest);
+            }
+            this.pages.set(key, { chunks: mdChunks, raw: rawChunks, ts: Date.now() });
+            setTimeout(() => this.pages.delete(key), TelegramAdapter.PAGE_TTL);
+            const keyboard = this.pageKeyboard(chatId, msgId, 0, mdChunks.length);
+            try {
+                await this.call("editMessageText", {
+                    chat_id: chatId,
+                    message_id: msgId,
+                    text: mdChunks[0],
+                    parse_mode: "MarkdownV2",
+                    reply_markup: keyboard,
+                });
+            }
+            catch {
                 try {
                     await this.call("editMessageText", {
                         chat_id: chatId,
                         message_id: msgId,
-                        text: mdChunks[0],
-                        parse_mode: "MarkdownV2",
+                        text: rawChunks[0],
                         reply_markup: keyboard,
                     });
                 }
-                catch {
-                    // MarkdownV2 failed, fallback to raw text
-                    try {
-                        await this.call("editMessageText", {
-                            chat_id: chatId,
-                            message_id: msgId,
-                            text: rawChunks[0],
-                            reply_markup: keyboard,
-                        });
-                    }
-                    catch { }
-                }
+                catch { }
             }
         }
-        catch (err) {
-            console.error("[telegram] claude error:", err);
-            await this.editMsg(chatId, msgId, `Error: ${err.message || "unknown"}`);
-        }
     }
     async start() {
         this.running = true;
         this.maxParallel = this.engine.getMaxParallel();
-        console.log(`[telegram] starting long polling... (max_parallel=${this.maxParallel})`);
+        log.info("starting long polling...", { maxParallel: this.maxParallel, multiSession: this.engine.isMultiSessionEnabled() });
         this.reminderTimer = setInterval(() => this.checkReminders(), 30000);
         this.autoTimer = setInterval(() => this.processAutoTasks(), 60000);
         this.approvalTimer = setInterval(() => this.checkApprovals(), 15000);
@@ -344,19 +391,19 @@ export class TelegramAdapter {
                 clearTimeout(timer);
                 const json = await res.json();
                 if (!json.ok) {
-                    console.error("[telegram] poll error:", json);
+                    log.error("poll error", { response: json });
                     continue;
                 }
                 pollBackoff = 0; // reset on success
                 for (const update of json.result) {
                     this.offset = update.update_id + 1;
-                    this.handleUpdate(update).catch(e => console.error("[telegram] handler error:", e));
+                    this.handleUpdate(update).catch(e => log.error("handler error", { error: e?.message }));
                 }
             }
             catch (err) {
                 pollBackoff = Math.min(pollBackoff + 1, 6);
                 const delay = Math.min(3000 * Math.pow(2, pollBackoff), 120000);
-                console.warn(`[telegram] poll error (retry in ${delay / 1000}s): ${err.cause?.code || err.message || "unknown"}`);
+                log.warn("poll error", { retryIn: delay / 1000, error: err.cause?.code || err.message || "unknown" });
                 await new Promise(r => setTimeout(r, delay));
             }
         }
@@ -373,10 +420,10 @@ export class TelegramAdapter {
     async registerCommands() {
         try {
             await this.call("setMyCommands", { commands: getCommandDescriptions(this.locale) });
-            console.log("[telegram] commands registered");
+            log.info("commands registered");
         }
         catch (e) {
-            console.error("[telegram] failed to register commands:", e);
+            log.error("failed to register commands", { error: e?.message });
         }
     }
     async checkReminders() {
@@ -388,7 +435,7 @@ export class TelegramAdapter {
             }
         }
         catch (e) {
-            console.error("[telegram] reminder error:", e);
+            log.error("reminder error", { error: e?.message });
         }
     }
     async processAutoTasks() {
@@ -406,7 +453,7 @@ export class TelegramAdapter {
         const chatId = Number(task.chat_id);
         await this.reply(chatId, t(this.locale, "auto_starting", { id: task.id, desc: task.description }));
         try {
-            console.log(`[telegram] auto-task #${task.id} for ${task.user_id}`);
+            log.info("auto-task starting", { taskId: task.id, userId: task.user_id });
             // Always use runParallel for auto-tasks: fresh session, no user session pollution
             const res = await this.engine.runParallel(task.user_id, task.description, "telegram", task.chat_id, undefined, 0);
             if (res.timedOut) {
@@ -483,7 +530,7 @@ export class TelegramAdapter {
             }
         }
         catch (e) {
-            console.error("[telegram] approval check error:", e);
+            log.error("approval check error", { error: e?.message });
         }
     }
     async handleApprovalCallback(cb) {
@@ -560,4 +607,22 @@ export class TelegramAdapter {
         const report = `${t(this.locale, "status_report")}\n${lines.join("\n")}\n\nSummary: ${summary}`;
         await this.reply(chatId, report);
     }
+    async handleSessionsCommand(chatId, userId) {
+        if (!this.engine.isMultiSessionEnabled()) {
+            await this.reply(chatId, "Multi-session mode is disabled.");
+            return;
+        }
+        const sessions = this.engine.getSessionManager().getActive(userId, "telegram");
+        if (!sessions.length) {
+            await this.reply(chatId, t(this.locale, "no_sessions"));
+            return;
+        }
+        const statusIcon = { active: "🟢", idle: "🟡", expired: "🔴", closed: "⚫" };
+        const lines = sessions.map(s => {
+            const ago = Math.round((Date.now() - s.lastActiveAt) / 60000);
+            const locked = this.engine.isSessionLocked(s.id) ? " [processing]" : "";
+            return `${statusIcon[s.status] || "⚪"} ${s.id.slice(0, 8)} "${s.label || "(no topic)"}" (${ago}min ago, ${s.messageCount} msgs, $${s.totalCost.toFixed(4)})${locked}`;
+        });
+        await this.reply(chatId, `${t(this.locale, "sessions_list")}\n${lines.join("\n")}`);
+    }
 }

package/dist/core/agent.d.ts

@@ -2,11 +2,15 @@ import { Config } from "./config.js";
 import { Store } from "./store.js";
 import { AccessControl } from "./permissions.js";
 import { EndpointRotator } from "./keys.js";
+import { SessionManager } from "./session.js";
+import { SessionRouter } from "./router.js";
 export interface AgentResponse {
     text: string;
     sessionId: string;
     cost?: number;
     timedOut?: boolean;
+    subSessionId?: string;
+    label?: string;
 }
 export type StreamCallback = (chunk: string, full: string) => void | Promise<void>;
 export declare class AgentEngine {
@@ -14,6 +18,9 @@ export declare class AgentEngine {
     private store;
     private lock;
     private rotator;
+    private sessionMgr;
+    private router;
+    private sessionExpiryTimer?;
     access: AccessControl;
     constructor(config: Config, store: Store);
     reloadConfig(config: Config): void;
@@ -24,12 +31,42 @@ export declare class AgentEngine {
     getRotator(): EndpointRotator;
     getEndpointCount(): number;
     getMaxParallel(): number;
+    getSessionManager(): SessionManager;
+    getRouter(): SessionRouter;
     getWorkDir(userId: string): string;
+    /** @deprecated Use isSessionLocked() for multi-session mode */
     isLocked(userId: string): boolean;
+    isSessionLocked(subSessionId: string): boolean;
+    isMultiSessionEnabled(): boolean;
+    /**
+     * Main entry point for user messages in multi-session mode.
+     * Routes to the correct sub-session and executes concurrently.
+     */
+    handleUserMessage(userId: string, prompt: string, platform: string, chatId: string, replyToMsgId?: string, onChunk?: StreamCallback, overrideTimeoutMs?: number): Promise<AgentResponse>;
+    /**
+     * Execute a prompt within a specific sub-session.
+     * Acquires per-session lock, resumes claude session via -r flag.
+     */
+    private _executeSubSession;
+    /**
+     * Core execution: spawn claude CLI with session resume for a sub-session.
+     * Thin wrapper around _spawnAgent with sub-session persistence.
+     */
+    private _executeWithSession;
+    /** Build the append system prompt (memories + skill doc) */
+    private _buildAppendPrompt;
+    /**
+     * Unified core: spawn provider CLI, parse stream, handle timeout.
+     * All execute methods delegate here.
+     */
+    private _spawnAgent;
+    /** @deprecated Use handleUserMessage() for multi-session mode */
     runStream(userId: string, prompt: string, platform: string, chatId: string, onChunk?: StreamCallback, overrideTimeoutMs?: number): Promise<AgentResponse>;
     runParallel(userId: string, prompt: string, platform: string, chatId: string, onChunk?: StreamCallback, overrideTimeoutMs?: number): Promise<AgentResponse>;
     private _executeWithRetry;
+    /** Legacy single-session execution. Thin wrapper around _spawnAgent with store persistence. */
     private _execute;
+    /** Parallel execution without session resume. Thin wrapper around _spawnAgent. */
     private _executeNoSession;
     private _autoSummarize;
 }