evolclaw 3.1.4 → 3.1.6

package/dist/core/session/session-manager.js

@@ -4,6 +4,7 @@ import { logger } from '../../utils/logger.js';
 import { encodePath } from '../../utils/cross-platform.js';
 import { chatDirPath, generateSessionId, formatTimestamp, atomicWriteJson, appendJsonl, readJsonFile, readLastJsonlLine, readAllJsonlLines, scanChatDirs, scanMetaFiles, ensureChatDir, readThreadIndex, writeThreadIndex, } from './session-fs-store.js';
 import { sessionToFile, fileToSession } from './session-mapper.js';
+import { formatSessionKey, DEFAULT_THREAD_ID } from './session-key.js';
 import path from 'path';
 import fs from 'fs';
 import os from 'os';
@@ -21,6 +22,7 @@ export class SessionManager {
         this.eventBus = eventBus;
         this.ownerResolver = ownerResolver;
         this.adminResolver = adminResolver;
+        this.migrateChannelKeyFormat();
     }
     setOwnerResolver(resolver) {
         this.ownerResolver = resolver;
@@ -87,83 +89,39 @@ export class SessionManager {
     // ─── File I/O helpers ───
     /**
      * 解析 chat 目录路径。
-     * 1. 先扫描所有 chat 目录，按 channelId 查找匹配项（同时 channelType==channel 或缺失时直接 channelId 匹配）
-     * 2. 找不到则按 fallback：channelType=channel（实例名），selfId=null
-     *
-     * 这样保持兼容：不知道 channelType 的 caller 仍可以用 (channel, channelId) 调用。
+     * 需要明确的 channelType + selfAID 才能确定路径。
      */
-    resolveChatDir(channel, channelId, channelType, selfId) {
-        // 必须有明确 channelType 才能确定路径
-        if (!channelType) {
-            throw new Error(`[SessionManager] resolveChatDir requires channelType. Got channel="${channel}" channelId="${channelId}". Caller must pass channelType (e.g. 'aun', 'feishu').`);
-        }
-        return chatDirPath(this.sessionsDir, channelType, channelId, selfId);
+    resolveChatDir(channel, channelId, channelType, selfAID) {
+        return chatDirPath(this.sessionsDir, channelType, channelId, selfAID);
     }
     /**
-     * 给定明确的 channelType + selfId 时直接计算路径（不扫描）。
+     * 给定明确的 channelType + selfAID 时直接计算路径（不扫描）。
      * 用于 caller 已经知道完整路由信息的场景（如 message-bridge 透传）。
      */
-    resolveChatDirExact(channel, channelId, channelType, selfId) {
-        if (channelType) {
-            return chatDirPath(this.sessionsDir, channelType, channelId, selfId);
-        }
-        return this.resolveChatDirSafe(channel, channelId);
+    resolveChatDirExact(channel, channelId, channelType, selfAID) {
+        return chatDirPath(this.sessionsDir, channelType, channelId, selfAID);
     }
     resolveChatDirFromSession(session) {
-        const channelType = session.channelType || session.channel;
-        return chatDirPath(this.sessionsDir, channelType, session.channelId, session.selfId);
+        if (!session.channelType) {
+            throw new Error(`[SessionManager] missing channelType for session ${session.id}`);
+        }
+        return chatDirPath(this.sessionsDir, session.channelType, session.channelId, session.selfAID);
     }
     /** Public accessor: get the chat directory path for a session (for message log etc.) */
     getChatDir(session) {
         return this.resolveChatDirFromSession(session);
     }
     /** Like resolveChatDir but also ensures the dir + _threads + _trash exist. */
-    ensureResolvedChatDir(channel, channelId, channelType, selfId) {
-        const dir = this.resolveChatDir(channel, channelId, channelType, selfId);
+    ensureResolvedChatDir(channel, channelId, channelType, selfAID) {
+        const dir = this.resolveChatDir(channel, channelId, channelType, selfAID);
         fs.mkdirSync(dir, { recursive: true });
         fs.mkdirSync(path.join(dir, '_threads'), { recursive: true });
         fs.mkdirSync(path.join(dir, '_trash'), { recursive: true });
         return dir;
     }
-    /** 推断给定 chat 的 channelType（优先取 active.json）。无活跃时回落到 channel 实例名。 */
-    inferChannelType(channel, channelId, chatDir) {
-        if (chatDir) {
-            const active = readJsonFile(path.join(chatDir, 'active.json'));
-            if (active?.channelType)
-                return active.channelType;
-        }
-        // 扫描已有目录
-        const dirs = scanChatDirs(this.sessionsDir);
-        for (const d of dirs) {
-            if (d.channelId !== channelId)
-                continue;
-            const active = readJsonFile(path.join(d.dirPath, 'active.json'));
-            if (active && active.channel === channel && active.channelType)
-                return active.channelType;
-        }
-        throw new Error(`[SessionManager] Cannot infer channelType for channel="${channel}" channelId="${channelId}". No existing session found.`);
-    }
-    /** 从 active 推断 selfId（已有 session 的复用） */
-    inferSelfId(channel, channelId, chatDir) {
-        if (chatDir) {
-            const active = readJsonFile(path.join(chatDir, 'active.json'));
-            if (active?.selfId)
-                return active.selfId;
-        }
-        // 扫描已有目录
-        const dirs = scanChatDirs(this.sessionsDir);
-        for (const d of dirs) {
-            if (d.channelId !== channelId)
-                continue;
-            const active = readJsonFile(path.join(d.dirPath, 'active.json'));
-            if (active && active.channel === channel)
-                return active.selfId || undefined;
-        }
-        return undefined;
-    }
     /**
      * 扫描已有 chat 目录，找到匹配 channel+channelId 的目录并返回其 chatDir 路径。
-     * 用于不知道 channelType/selfId 的 caller 在调用 resolveChatDir 前定位已有目录。
+     * 用于不知道 channelType/selfAID 的 caller 在调用 resolveChatDir 前定位已有目录。
      */
     findExistingChatDir(channel, channelId) {
         const dirs = scanChatDirs(this.sessionsDir);
@@ -194,26 +152,26 @@ export class SessionManager {
         return undefined;
     }
     /**
-     * 安全版 resolveChatDir：先尝试用提供的 channelType/selfId，
+     * 安全版 resolveChatDir：先尝试用提供的 channelType/selfAID，
      * 如果没有则扫描已有目录推断。用于操作已有 session 的公共方法。
      */
-    resolveChatDirSafe(channel, channelId, channelType, selfId) {
-        if (channelType) {
-            return this.resolveChatDir(channel, channelId, channelType, selfId);
+    resolveChatDirSafe(channel, channelId, channelType, selfAID) {
+        if (channelType && (selfAID || channelType !== 'aun')) {
+            return this.resolveChatDir(channel, channelId, channelType, selfAID);
         }
         // 尝试从已有目录推断
         const existingDir = this.findExistingChatDir(channel, channelId);
         if (existingDir)
             return existingDir;
-        throw new Error(`[SessionManager] Cannot resolve chat dir for channel="${channel}" channelId="${channelId}". No channelType provided and no existing session found.`);
+        throw new Error(`[SessionManager] Cannot resolve chat dir for channel="${channel}" channelId="${channelId}". No channelType/selfAID provided and no existing session found.`);
     }
     /**
-     * 安全版 ensureResolvedChatDir：先尝试用提供的 channelType/selfId，
+     * 安全版 ensureResolvedChatDir：先尝试用提供的 channelType/selfAID，
      * 如果没有则扫描已有目录推断。确保目录存在。
      */
-    ensureResolvedChatDirSafe(channel, channelId, channelType, selfId) {
-        if (channelType) {
-            return this.ensureResolvedChatDir(channel, channelId, channelType, selfId);
+    ensureResolvedChatDirSafe(channel, channelId, channelType, selfAID) {
+        if (channelType && (selfAID || channelType !== 'aun')) {
+            return this.ensureResolvedChatDir(channel, channelId, channelType, selfAID);
         }
         // 尝试从已有目录推断
         const existingDir = this.findExistingChatDir(channel, channelId);
@@ -224,18 +182,14 @@ export class SessionManager {
             fs.mkdirSync(path.join(existingDir, '_trash'), { recursive: true });
             return existingDir;
         }
-        // 回退：推断 channelType 和 selfId
-        const inferredType = this.inferChannelType(channel, channelId);
-        const inferredSelfId = this.inferSelfId(channel, channelId);
-        return this.ensureResolvedChatDir(channel, channelId, inferredType, inferredSelfId);
+        throw new Error(`[SessionManager] Cannot resolve chat dir for channel="${channel}" channelId="${channelId}". No channelType/selfAID provided and no existing session found.`);
     }
-    readActive(channel, channelId, channelType, selfId) {
+    readActive(channel, channelId, channelType, selfAID) {
         let dir;
-        try {
-            dir = this.resolveChatDir(channel, channelId, channelType, selfId);
+        if (channelType && selfAID) {
+            dir = this.resolveChatDir(channel, channelId, channelType, selfAID);
         }
-        catch {
-            // channelType not provided — try to find existing dir
+        else {
             const existingDir = this.findExistingChatDir(channel, channelId);
             if (!existingDir)
                 return undefined;
@@ -251,12 +205,12 @@ export class SessionManager {
         const file = sessionToFile(session);
         atomicWriteJson(path.join(dir, 'active.json'), file);
     }
-    clearActive(channel, channelId, channelType, selfId) {
+    clearActive(channel, channelId, channelType, selfAID) {
         let dir;
-        try {
-            dir = this.resolveChatDir(channel, channelId, channelType, selfId);
+        if (channelType && selfAID) {
+            dir = this.resolveChatDir(channel, channelId, channelType, selfAID);
         }
-        catch {
+        else {
             const existingDir = this.findExistingChatDir(channel, channelId);
             if (!existingDir)
                 return;
@@ -273,51 +227,72 @@ export class SessionManager {
     }
     ensureChatDirForSession(session) {
         const channelType = session.channelType || session.channel;
-        return ensureChatDir(this.sessionsDir, channelType, session.channelId, session.selfId);
+        return ensureChatDir(this.sessionsDir, channelType, session.channelId, session.selfAID);
     }
     metaFilePath(chatDir, sessionId) {
         return path.join(chatDir, `${sessionId}.jsonl`);
     }
-    appendMeta(channel, channelId, session) {
+    /** 由 session 自身的 channelType/channelId/selfId/threadId 直接定位其 .jsonl 路径（不扫描目录）。 */
+    metaPathForSession(session) {
         const dir = this.ensureChatDirForSession(session);
-        const isThread = !!session.threadId;
-        const targetDir = isThread ? path.join(dir, '_threads') : dir;
-        const file = sessionToFile(session);
-        const metaPath = this.metaFilePath(targetDir, session.id);
-        appendJsonl(metaPath, file);
+        const targetDir = session.threadId ? path.join(dir, '_threads') : dir;
+        return this.metaFilePath(targetDir, session.id);
     }
-    /**
-     * 比较两个 SessionFile 是否在内容上相等（忽略 updatedAt / updatedAtStr）。
-     * 用于跳过"没真变化"的写入，避免 jsonl 写放大。
-     */
-    sessionFilesEqual(a, b) {
-        const stripVolatile = ({ updatedAt, updatedAtStr, ...rest }) => rest;
-        return JSON.stringify(stripVolatile(a)) === JSON.stringify(stripVolatile(b));
+    appendMeta(channel, channelId, session) {
+        const file = sessionToFile(session);
+        appendJsonl(this.metaPathForSession(session), file);
     }
     /**
-     * Append meta + write active.json，但只在 session 内容（除 updatedAt 外）真正变化时才写。
-     * prev 是修改前的快照（用于 diff），next 是修改后的 session。
-     * 返回是否发生了写入。
+     * Session 持久化的唯一事务原语。所有 session 写操作都应经此，业务层不直接调
+     * appendMeta / writeActive。
+     *
+     * 契约：.jsonl 是权威源，active.json 是热缓存。
+     *   1. 内建 diff 去重：与该 session 的 .jsonl 末行比较（忽略 updatedAt），无变化则跳过
+     *   2. appendMeta(.jsonl) —— 始终先落历史档案（权威源）
+     *   3. 按 intent 决定 active.json 行为：
+     *      - 'set'  : 无条件让该 session 成为 active（创建/切换主会话）
+     *      - 'sync' : 仅当该 session 已是当前 active 时同步缓存（更新自身字段）
+     *      - 'none' : 不碰 active.json（thread 会话 / 后台 autonomous 会话）
+     *
+     * @param session   要持久化的 session（其 updatedAt 会被刷新）
+     * @param intent    active.json 行为意图
+     * @param opts.forceWrite  强制写入一条新记录，跳过去重。用于 markProcessing/clearProcessing
+     *                         这类"状态转换事件必须留痕"的场景。
+     * @returns 是否真的写入了 .jsonl（去重命中时返回 false）
      */
-    writeSessionIfChanged(channel, channelId, prev, next) {
-        if (prev) {
-            const prevFile = sessionToFile(prev);
-            const nextFile = sessionToFile(next);
-            if (this.sessionFilesEqual(prevFile, nextFile))
+    persistSession(session, intent, opts) {
+        if (!opts?.forceWrite) {
+            const lastMeta = readLastJsonlLine(this.metaPathForSession(session));
+            if (lastMeta && this.sessionFilesEqual(lastMeta, sessionToFile(session))) {
+                // .jsonl 末行已与目标一致：仍可能需要把缓存对齐（'set' 语义）
+                if (intent === 'set') {
+                    session.updatedAt = Date.now();
+                    this.writeActive(session.channel, session.channelId, session);
+                }
                 return false;
+            }
         }
-        next.updatedAt = Date.now();
-        this.appendMeta(channel, channelId, next);
-        const active = this.readActive(channel, channelId);
-        if (active && active.id === next.id) {
-            // 保留 active.json 中已有的 activeTask（markProcessing 写入的处理状态）
-            if (active.processingState && !next.processingState) {
-                next.processingState = active.processingState;
+        session.updatedAt = Date.now();
+        this.appendMeta(session.channel, session.channelId, session);
+        if (intent === 'set') {
+            this.writeActive(session.channel, session.channelId, session);
+        }
+        else if (intent === 'sync') {
+            const active = this.readActive(session.channel, session.channelId);
+            if (active && active.id === session.id) {
+                this.writeActive(session.channel, session.channelId, session);
             }
-            this.writeActive(channel, channelId, next);
         }
         return true;
     }
+    /**
+     * 比较两个 SessionFile 是否在内容上相等（忽略 updatedAt / updatedAtStr）。
+     * 用于跳过"没真变化"的写入，避免 jsonl 写放大。
+     */
+    sessionFilesEqual(a, b) {
+        const stripVolatile = ({ updatedAt, updatedAtStr, ...rest }) => rest;
+        return JSON.stringify(stripVolatile(a)) === JSON.stringify(stripVolatile(b));
+    }
     readMetaLatest(metaFilePath) {
         const file = readLastJsonlLine(metaFilePath);
         if (!file)
@@ -335,9 +310,7 @@ export class SessionManager {
      *   2. 优先读 active.json（如果 active.id === sessionId）—— 当前状态
      *   3. 否则 fallback 到 .jsonl 末行 —— 非活跃 session 的更新（如多 session 并存时改非 active 那个）
      *
-     * 返回 { current, prev }：
-     *   - current 用于 caller 修改后写回
-     *   - prev 是 current 的初始快照（用于 writeSessionIfChanged 的 diff 检查）
+     * 返回 { current }：caller 修改后交给 persistSession 写回（去重由 persistSession 内建）。
      */
     loadSessionForUpdate(sessionId) {
         const found = this.findSessionFileById(sessionId);
@@ -350,10 +323,8 @@ export class SessionManager {
         // 优先用 active.json 的当前状态（如果它就是这个 sessionId）
         const active = this.readActive(fromJsonl.channel, fromJsonl.channelId);
         const base = (active && active.id === sessionId) ? active : fromJsonl;
-        // 深拷贝避免 caller 改 current 时污染 prev
         const current = JSON.parse(JSON.stringify(base));
-        const prev = JSON.parse(JSON.stringify(base));
-        return { current, prev };
+        return { current };
     }
     validateSessionFile(session) {
         const agentSessionId = session.agentSessionId;
@@ -366,9 +337,8 @@ export class SessionManager {
         if (adapter.checkExists(session.projectPath, agentSessionId))
             return agentSessionId;
         logger.warn(`Session file not found for ${agentId}: ${agentSessionId}, clearing session ID`);
-        const prev = JSON.parse(JSON.stringify(session));
         session.agentSessionId = undefined;
-        this.writeSessionIfChanged(session.channel, session.channelId, prev, session);
+        this.persistSession(session, 'sync');
         return undefined;
     }
     getActiveChatType(channel, channelId) {
@@ -433,17 +403,14 @@ export class SessionManager {
     markProcessing(sessionId, taskId) {
         const now = Date.now();
         const state = taskId ? `${now}:${taskId}` : String(now);
-        const chatDirs = scanChatDirs(this.sessionsDir);
-        for (const { dirPath } of chatDirs) {
-            const active = readJsonFile(path.join(dirPath, 'active.json'));
-            if (active && active.id === sessionId) {
-                active.activeTask = state;
-                active.updatedAt = now;
-                active.updatedAtStr = formatTimestamp(now);
-                atomicWriteJson(path.join(dirPath, 'active.json'), active);
-                return;
-            }
-        }
+        const found = this.findSessionFileById(sessionId);
+        if (!found)
+            return;
+        const session = this.readMetaLatest(found.metaPath);
+        if (!session)
+            return;
+        session.processingState = state;
+        this.persistSession(session, 'sync', { forceWrite: true });
     }
     getActiveTaskId(sessionId) {
         const chatDirs = scanChatDirs(this.sessionsDir);
@@ -459,17 +426,20 @@ export class SessionManager {
         return undefined;
     }
     clearProcessing(sessionId) {
-        const now = Date.now();
-        const chatDirs = scanChatDirs(this.sessionsDir);
-        for (const { dirPath } of chatDirs) {
-            const active = readJsonFile(path.join(dirPath, 'active.json'));
-            if (active && active.id === sessionId) {
-                active.activeTask = null;
-                active.updatedAt = now;
-                active.updatedAtStr = formatTimestamp(now);
-                atomicWriteJson(path.join(dirPath, 'active.json'), active);
-                break;
-            }
+        const found = this.findSessionFileById(sessionId);
+        if (!found) {
+            this.sessionEncryptState.delete(sessionId);
+            return;
+        }
+        const session = this.readMetaLatest(found.metaPath);
+        if (!session) {
+            this.sessionEncryptState.delete(sessionId);
+            return;
+        }
+        // 仅当 .jsonl 末行确实有 activeTask 时才写（避免写放大）
+        if (session.processingState) {
+            session.processingState = undefined;
+            this.persistSession(session, 'sync', { forceWrite: true });
         }
         this.sessionEncryptState.delete(sessionId);
     }
@@ -484,36 +454,41 @@ export class SessionManager {
         const result = [];
         const chatDirs = scanChatDirs(this.sessionsDir);
         for (const { dirPath } of chatDirs) {
-            const active = readJsonFile(path.join(dirPath, 'active.json'));
-            if (!active || !active.activeTask)
-                continue;
-            const colonIdx = active.activeTask.indexOf(':');
-            const ts = parseInt(colonIdx > 0 ? active.activeTask.slice(0, colonIdx) : active.activeTask, 10);
-            if (!isNaN(ts) && (now - ts) < maxAgeMs) {
-                result.push(fileToSession(active));
-            }
-            else {
-                active.activeTask = null;
-                active.updatedAt = now;
-                active.updatedAtStr = formatTimestamp(now);
-                atomicWriteJson(path.join(dirPath, 'active.json'), active);
+            for (const metaFile of scanMetaFiles(dirPath)) {
+                const session = this.readMetaLatest(path.join(dirPath, metaFile));
+                if (!session?.processingState)
+                    continue;
+                const colonIdx = session.processingState.indexOf(':');
+                const ts = parseInt(colonIdx > 0 ? session.processingState.slice(0, colonIdx) : session.processingState, 10);
+                if (!isNaN(ts) && (now - ts) < maxAgeMs) {
+                    result.push(session);
+                }
+                else {
+                    this.clearProcessing(session.id);
+                }
             }
         }
         return result;
     }
     // ─── Session lifecycle ───
-    async getOrCreateSession(channel, channelId, defaultProjectPath, threadId, metadata, name, userId, chatType, agentId, selfId, channelType, peerType) {
+    async getOrCreateSession(channel, channelId, defaultProjectPath, threadId, metadata, name, userId, chatType, agentId, selfAID, channelType, peerType) {
+        if (!selfAID && channelType === 'aun') {
+            throw new Error(`[SessionManager] getOrCreateSession requires selfAID for aun channel. channelId="${channelId}"`);
+        }
+        if (!channelType) {
+            throw new Error(`[SessionManager] getOrCreateSession requires channelType. channel="${channel}" channelId="${channelId}"`);
+        }
         if (threadId) {
-            const session = this.getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, agentId, selfId, channelType, peerType);
+            const session = this.getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, agentId, selfAID, channelType, peerType);
             session.identity = this.resolveIdentity(channel, userId);
             if (session.metadata && !session.metadata.permissionMode) {
                 session.metadata.permissionMode = DEFAULT_PERMISSION_MODE;
-                this.appendMeta(channel, channelId, session);
+                this.persistSession(session, 'none');
             }
             return session;
         }
         // 使用精确路径解析（caller 提供了 channelType 时直接定位，避免扫描回落）
-        const exactDir = this.resolveChatDirExact(channel, channelId, channelType, selfId);
+        const exactDir = this.resolveChatDirExact(channel, channelId, channelType, selfAID);
         const activeFile = readJsonFile(path.join(exactDir, 'active.json'));
         const active = activeFile ? fileToSession(activeFile) : undefined;
         if (active && !active.threadId) {
@@ -526,8 +501,8 @@ export class SessionManager {
                 session.chatType = chatType;
                 mutated = true;
             }
-            if (selfId && session.selfId !== selfId) {
-                session.selfId = selfId;
+            if (session.selfAID !== selfAID) {
+                session.selfAID = selfAID;
                 mutated = true;
             }
             if (chatType === 'private' && userId) {
@@ -541,41 +516,38 @@ export class SessionManager {
                     session.metadata.peerName = metadata.peerName;
                     mutated = true;
                 }
-                if (metadata?.channelName && session.metadata.channelName !== metadata.channelName) {
-                    session.metadata.channelName = metadata.channelName;
+                if (metadata?.channelKey && session.metadata.channelKey !== metadata.channelKey) {
+                    session.metadata.channelKey = metadata.channelKey;
                     mutated = true;
                 }
             }
-            if (metadata?.channelName && chatType !== 'private') {
+            if (metadata?.channelKey && chatType !== 'private') {
                 if (!session.metadata)
                     session.metadata = {};
-                if (session.metadata.channelName !== metadata.channelName) {
-                    session.metadata.channelName = metadata.channelName;
+                if (session.metadata.channelKey !== metadata.channelKey) {
+                    session.metadata.channelKey = metadata.channelKey;
                     mutated = true;
                 }
             }
             if (mutated) {
-                session.updatedAt = Date.now();
-                this.appendMeta(channel, channelId, session);
-                this.writeActive(channel, channelId, session);
+                this.persistSession(session, 'sync');
             }
             return session;
         }
         // Find existing session for default project path
-        const chatDir = this.resolveChatDir(channel, channelId, channelType, selfId);
+        const chatDir = this.resolveChatDir(channel, channelId, channelType, selfAID);
         const allSessions = this.findAllSessionsInChat(chatDir, false);
         const existing = allSessions
             .filter(s => s.projectPath === defaultProjectPath && !s.threadId)
             .sort((a, b) => b.updatedAt - a.updatedAt)[0];
         if (existing) {
             const validSessionId = this.validateSessionFile(existing);
-            const prev = JSON.parse(JSON.stringify({ ...existing, agentSessionId: validSessionId }));
             const session = { ...existing, agentSessionId: validSessionId };
             session.identity = this.resolveIdentity(channel, userId);
             if (!session.metadata)
                 session.metadata = {};
-            if (selfId && session.selfId !== selfId) {
-                session.selfId = selfId;
+            if (session.selfAID !== selfAID) {
+                session.selfAID = selfAID;
             }
             if (chatType && session.chatType !== chatType) {
                 logger.info(`[SessionManager] Updating chatType for session ${session.id}: ${session.chatType} -> ${chatType}`);
@@ -587,7 +559,7 @@ export class SessionManager {
             if (chatType === 'private' && metadata?.peerName && !session.metadata.peerName) {
                 session.metadata.peerName = metadata.peerName;
             }
-            this.writeSessionIfChanged(channel, channelId, prev, session);
+            this.persistSession(session, 'sync');
             return session;
         }
         // Create new session
@@ -597,12 +569,13 @@ export class SessionManager {
         const session = {
             id: generateSessionId(),
             channel,
-            channelType: channelType || channel,
+            channelType,
             channelId,
-            selfId,
+            selfAID,
             projectPath: defaultProjectPath,
             threadId: '',
             agentId: agentId || 'claude',
+            sessionKey: formatSessionKey(channelType, channelId, DEFAULT_THREAD_ID),
             chatType: chatType || 'private',
             sessionMode: this.resolveDefaultSessionMode(channel, chatType || 'private', peerType),
             metadata: sessionMetadata,
@@ -611,8 +584,7 @@ export class SessionManager {
             updatedAt: Date.now(),
         };
         session.identity = this.resolveIdentity(channel, userId);
-        this.appendMeta(channel, channelId, session);
-        this.writeActive(channel, channelId, session);
+        this.persistSession(session, 'set');
         this.eventBus.publish({
             type: 'session:created',
             sessionId: session.id,
@@ -629,7 +601,7 @@ export class SessionManager {
         const loaded = this.loadSessionForUpdate(sessionId);
         if (!loaded)
             return;
-        const { current, prev } = loaded;
+        const { current } = loaded;
         if (updates.chatType !== undefined)
             current.chatType = updates.chatType;
         if (updates.name !== undefined)
@@ -640,41 +612,43 @@ export class SessionManager {
             current.metadata = updates.metadata;
         if ('agentSessionId' in updates)
             current.agentSessionId = updates.agentSessionId ?? undefined;
-        this.writeSessionIfChanged(current.channel, current.channelId, prev, current);
+        this.persistSession(current, 'sync');
     }
-    getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, agentId, selfId, channelType, peerType) {
-        // 优先使用精确路径（channelType + selfId），避免 fallback 到错误目录
-        const chatDir = (channelType && selfId)
-            ? (() => { const d = chatDirPath(this.sessionsDir, channelType, channelId, selfId); fs.mkdirSync(d, { recursive: true }); fs.mkdirSync(path.join(d, '_threads'), { recursive: true }); return d; })()
-            : this.ensureResolvedChatDirSafe(channel, channelId, channelType);
+    getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, agentId, selfAID, channelType, peerType) {
+        // 使用精确路径（channelType + selfAID）
+        const chatDir = (channelType && selfAID)
+            ? (() => { const d = chatDirPath(this.sessionsDir, channelType, channelId, selfAID); fs.mkdirSync(d, { recursive: true }); fs.mkdirSync(path.join(d, '_threads'), { recursive: true }); return d; })()
+            : this.ensureResolvedChatDirSafe(channel, channelId, channelType, selfAID);
         const threadIndex = readThreadIndex(chatDir);
-        const existingMetaId = threadIndex[threadId];
-        if (existingMetaId) {
-            const metaPath = path.join(chatDir, '_threads', `${existingMetaId}.jsonl`);
+        const existingEntry = threadIndex[threadId];
+        if (existingEntry) {
+            const metaPath = path.join(chatDir, '_threads', `${existingEntry.sessionId}.jsonl`);
             const existing = this.readMetaLatest(metaPath);
             if (existing) {
                 const validSessionId = this.validateSessionFile(existing);
                 if (metadata) {
                     existing.metadata = { ...(existing.metadata || {}), ...metadata };
-                    existing.updatedAt = Date.now();
-                    this.appendMeta(channel, channelId, existing);
+                    this.persistSession(existing, 'none');
                 }
                 return { ...existing, agentSessionId: validSessionId };
             }
         }
         // Inherit project path & chatType from active main session
-        const activeMain = this.readActive(channel, channelId, channelType, selfId);
+        const activeMain = this.readActive(channel, channelId, channelType, selfAID);
         const projectPath = (activeMain && !activeMain.threadId ? activeMain.projectPath : undefined) || defaultProjectPath;
         const inheritedChatType = (activeMain && !activeMain.threadId ? activeMain.chatType : undefined) || 'private';
+        const effectiveChannelType = channelType || channel;
+        const sessionKey = formatSessionKey(effectiveChannelType, channelId, threadId);
         const session = {
             id: generateSessionId(),
             channel,
-            channelType: channelType || channel,
+            channelType: effectiveChannelType,
             channelId,
-            selfId,
+            selfAID: selfAID || '',
             projectPath,
             threadId,
             agentId: agentId || 'claude',
+            sessionKey,
             chatType: inheritedChatType,
             sessionMode: this.resolveDefaultSessionMode(channel, inheritedChatType, peerType),
             metadata,
@@ -682,8 +656,12 @@ export class SessionManager {
             createdAt: Date.now(),
             updatedAt: Date.now(),
         };
-        this.appendMeta(channel, channelId, session);
-        threadIndex[threadId] = session.id;
+        this.persistSession(session, 'none');
+        threadIndex[threadId] = {
+            sessionId: session.id,
+            sessionKey,
+            metaFile: `${session.id}.jsonl`,
+        };
         writeThreadIndex(chatDir, threadIndex);
         this.eventBus.publish({
             type: 'session:created',
@@ -708,20 +686,23 @@ export class SessionManager {
         if (target) {
             const validSessionId = this.validateSessionFile(target);
             target.agentSessionId = validSessionId;
-            target.updatedAt = Date.now();
-            this.appendMeta(channel, channelId, target);
-            this.writeActive(channel, channelId, target);
+            this.persistSession(target, 'set');
             return target;
         }
+        // Derive selfAID and channelType from existing sessions in this chatDir
+        const existingAny = allSessions[0];
+        const selfAID = existingAny?.selfAID || '';
+        const channelType = existingAny?.channelType || channel;
         const session = {
             id: generateSessionId(),
             channel,
-            channelType: this.inferChannelType(channel, channelId),
+            channelType,
             channelId,
-            selfId: this.inferSelfId(channel, channelId),
+            selfAID,
             projectPath: newProjectPath,
             threadId: '',
             agentId,
+            sessionKey: formatSessionKey(channelType, channelId, DEFAULT_THREAD_ID),
             chatType: inheritedChatType,
             sessionMode: this.resolveDefaultSessionMode(channel, inheritedChatType),
             metadata: {},
@@ -729,8 +710,7 @@ export class SessionManager {
             createdAt: Date.now(),
             updatedAt: Date.now(),
         };
-        this.appendMeta(channel, channelId, session);
-        this.writeActive(channel, channelId, session);
+        this.persistSession(session, 'set');
         this.eventBus.publish({
             type: 'session:created',
             sessionId: session.id,
@@ -746,24 +726,29 @@ export class SessionManager {
         const active = this.readActive(channel, channelId);
         if (!active)
             return;
-        const prev = JSON.parse(JSON.stringify(active));
         active.agentSessionId = agentSessionId;
-        this.writeSessionIfChanged(channel, channelId, prev, active);
+        this.persistSession(active, 'sync');
     }
     async updateAgentSessionIdBySessionId(sessionId, agentSessionId) {
         const loaded = this.loadSessionForUpdate(sessionId);
         if (!loaded)
             return;
-        const { current, prev } = loaded;
+        const { current } = loaded;
         current.agentSessionId = agentSessionId;
-        const wrote = this.writeSessionIfChanged(current.channel, current.channelId, prev, current);
+        const wrote = this.persistSession(current, 'sync');
         if (wrote) {
             logger.info(`[SessionManager] Updating agent_session_id: sessionId=${sessionId}, agentSessionId=${agentSessionId}`);
         }
     }
     async switchAgent(channel, channelId, projectPath, newAgentId) {
         const inheritedChatType = this.getActiveChatType(channel, channelId);
-        const chatDir = this.ensureResolvedChatDirSafe(channel, channelId);
+        // Derive channelType/selfAID from existing sessions; fall back to channel name
+        const probeChatDir = this.resolveChatDir(channel, channelId, channel, '');
+        const probeSessions = fs.existsSync(probeChatDir) ? this.findAllSessionsInChat(probeChatDir, false) : [];
+        const existingAny = probeSessions[0];
+        const channelType = existingAny?.channelType || channel;
+        const selfAID = existingAny?.selfAID || '';
+        const chatDir = this.ensureResolvedChatDir(channel, channelId, channelType, selfAID);
         const allSessions = this.findAllSessionsInChat(chatDir, false);
         const target = allSessions
             .filter(s => s.projectPath === projectPath && (s.agentId || 'claude') === newAgentId && !s.threadId)
@@ -771,20 +756,19 @@ export class SessionManager {
         if (target) {
             const validSessionId = this.validateSessionFile(target);
             target.agentSessionId = validSessionId;
-            target.updatedAt = Date.now();
-            this.appendMeta(channel, channelId, target);
-            this.writeActive(channel, channelId, target);
+            this.persistSession(target, 'set');
             return target;
         }
         const session = {
             id: generateSessionId(),
             channel,
-            channelType: this.inferChannelType(channel, channelId),
+            channelType,
             channelId,
-            selfId: this.inferSelfId(channel, channelId),
+            selfAID,
             projectPath,
             threadId: '',
             agentId: newAgentId,
+            sessionKey: formatSessionKey(channelType, channelId, DEFAULT_THREAD_ID),
             chatType: inheritedChatType,
             sessionMode: this.resolveDefaultSessionMode(channel, inheritedChatType),
             metadata: {},
@@ -792,8 +776,7 @@ export class SessionManager {
             createdAt: Date.now(),
             updatedAt: Date.now(),
         };
-        this.appendMeta(channel, channelId, session);
-        this.writeActive(channel, channelId, session);
+        this.persistSession(session, 'set');
         this.eventBus.publish({
             type: 'session:created',
             sessionId: session.id,
@@ -809,9 +792,8 @@ export class SessionManager {
         const active = this.readActive(channel, channelId);
         if (!active)
             return;
-        const prev = JSON.parse(JSON.stringify(active));
         active.agentSessionId = undefined;
-        this.writeSessionIfChanged(channel, channelId, prev, active);
+        this.persistSession(active, 'sync');
     }
     getOwnerChatId(targetChannel, ownerPeerId) {
         const chatDirs = scanChatDirs(this.sessionsDir);
@@ -851,8 +833,8 @@ export class SessionManager {
         return this.readActive(channel, channelId);
     }
     /** 同步版 getActiveSession，支持精确路径定位（避免扫描） */
-    getActiveSessionSync(channel, channelId, channelType, selfId) {
-        return this.readActive(channel, channelId, channelType, selfId);
+    getActiveSessionSync(channel, channelId, channelType, selfAID) {
+        return this.readActive(channel, channelId, channelType, selfAID);
     }
     async getThreadSession(channel, channelId, threadId) {
         let chatDir;
@@ -863,10 +845,10 @@ export class SessionManager {
             return undefined;
         }
         const threadIndex = readThreadIndex(chatDir);
-        const metaId = threadIndex[threadId];
-        if (!metaId)
+        const entry = threadIndex[threadId];
+        if (!entry)
             return undefined;
-        const metaPath = path.join(chatDir, '_threads', `${metaId}.jsonl`);
+        const metaPath = path.join(chatDir, '_threads', `${entry.sessionId}.jsonl`);
         const session = this.readMetaLatest(metaPath);
         if (!session)
             return undefined;
@@ -928,26 +910,24 @@ export class SessionManager {
         const target = sessions.find(s => s.id === targetSessionId);
         if (!target)
             return null;
-        target.updatedAt = Date.now();
-        this.appendMeta(channel, channelId, target);
-        this.writeActive(channel, channelId, target);
+        this.persistSession(target, 'set');
         return target;
     }
     updateMetadata(sessionId, metadata) {
         const loaded = this.loadSessionForUpdate(sessionId);
         if (!loaded)
             return;
-        const { current, prev } = loaded;
+        const { current } = loaded;
         current.metadata = metadata;
-        this.writeSessionIfChanged(current.channel, current.channelId, prev, current);
+        this.persistSession(current, 'sync');
     }
     async renameSession(sessionId, newName) {
         const loaded = this.loadSessionForUpdate(sessionId);
         if (!loaded)
             return false;
-        const { current, prev } = loaded;
+        const { current } = loaded;
         current.name = newName;
-        this.writeSessionIfChanged(current.channel, current.channelId, prev, current);
+        this.persistSession(current, 'sync');
         return true;
     }
     async unbindSession(sessionId) {
@@ -967,8 +947,8 @@ export class SessionManager {
         // If thread session, remove from thread-index
         if (found.isThread) {
             const threadIndex = readThreadIndex(found.chatDir);
-            for (const [tid, mid] of Object.entries(threadIndex)) {
-                if (mid === sessionId) {
+            for (const [tid, entry] of Object.entries(threadIndex)) {
+                if (entry.sessionId === sessionId) {
                     delete threadIndex[tid];
                     break;
                 }
@@ -1040,34 +1020,35 @@ export class SessionManager {
     }
     async createNewSession(channel, channelId, projectPath, name, agentId) {
         const inheritedChatType = this.getActiveChatType(channel, channelId);
-        let inferredType;
-        let inferredSelfId;
-        try {
-            inferredType = this.inferChannelType(channel, channelId);
-            inferredSelfId = this.inferSelfId(channel, channelId);
-        }
-        catch {
-            inferredType = channel;
-            inferredSelfId = undefined;
+        // Derive selfAID and channelType from existing sessions
+        const existingDir = this.findExistingChatDir(channel, channelId);
+        let channelType = channel;
+        let selfAID = '';
+        if (existingDir) {
+            const active = readJsonFile(path.join(existingDir, 'active.json'));
+            if (active) {
+                channelType = active.channelType || channel;
+                selfAID = active.selfAID || '';
+            }
         }
         const session = {
             id: generateSessionId(),
             channel,
-            channelType: inferredType,
+            channelType,
             channelId,
-            selfId: inferredSelfId,
+            selfAID,
             projectPath,
             threadId: '',
             agentId: agentId || 'claude',
+            sessionKey: formatSessionKey(channelType, channelId, DEFAULT_THREAD_ID),
             chatType: inheritedChatType,
             sessionMode: this.resolveDefaultSessionMode(channel, inheritedChatType),
-            metadata: {},
+            metadata: { permissionMode: DEFAULT_PERMISSION_MODE },
             name: name || '默认会话',
             createdAt: Date.now(),
             updatedAt: Date.now(),
         };
-        this.appendMeta(channel, channelId, session);
-        this.writeActive(channel, channelId, session);
+        this.persistSession(session, 'set');
         this.eventBus.publish({
             type: 'session:created',
             sessionId: session.id,
@@ -1080,25 +1061,27 @@ export class SessionManager {
         return session;
     }
     async createForkedSession(sourceSession, forkedAgentSessionId, name) {
+        const channelType = sourceSession.channelType || sourceSession.channel;
+        const threadId = sourceSession.threadId || '';
         const session = {
             id: generateSessionId(),
             channel: sourceSession.channel,
-            channelType: sourceSession.channelType || sourceSession.channel,
+            channelType,
             channelId: sourceSession.channelId,
-            selfId: sourceSession.selfId,
+            selfAID: sourceSession.selfAID,
             projectPath: sourceSession.projectPath,
-            threadId: sourceSession.threadId || '',
+            threadId,
             agentId: sourceSession.agentId || 'claude',
+            sessionKey: formatSessionKey(channelType, sourceSession.channelId, threadId || DEFAULT_THREAD_ID),
             chatType: sourceSession.chatType || 'private',
             sessionMode: sourceSession.sessionMode || 'interactive',
             agentSessionId: forkedAgentSessionId,
-            metadata: {},
+            metadata: { permissionMode: sourceSession.metadata?.permissionMode || DEFAULT_PERMISSION_MODE },
             name: name || `${sourceSession.name || '会话'}-分支`,
             createdAt: Date.now(),
             updatedAt: Date.now(),
         };
-        this.appendMeta(sourceSession.channel, sourceSession.channelId, session);
-        this.writeActive(sourceSession.channel, sourceSession.channelId, session);
+        this.persistSession(session, 'set');
         this.eventBus.publish({
             type: 'session:created',
             sessionId: session.id,
@@ -1161,15 +1144,27 @@ export class SessionManager {
         const inheritedChatType = this.getActiveChatType(channel, channelId);
         const fileInfo = this.getSessionFileInfo(projectPath, agentSessionId, agentId);
         const name = fileInfo.title || `CLI会话-${new Date().toLocaleString('zh-CN', { month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' })}`;
+        // Derive selfAID and channelType from existing sessions
+        const existingDir = this.findExistingChatDir(channel, channelId);
+        let channelType = channel;
+        let selfAID = '';
+        if (existingDir) {
+            const active = readJsonFile(path.join(existingDir, 'active.json'));
+            if (active) {
+                channelType = active.channelType || channel;
+                selfAID = active.selfAID || '';
+            }
+        }
         const session = {
             id: generateSessionId(),
             channel,
-            channelType: this.inferChannelType(channel, channelId),
+            channelType,
             channelId,
-            selfId: this.inferSelfId(channel, channelId),
+            selfAID,
             projectPath,
             threadId: '',
             agentId,
+            sessionKey: formatSessionKey(channelType, channelId, DEFAULT_THREAD_ID),
             chatType: inheritedChatType,
             sessionMode: this.resolveDefaultSessionMode(channel, inheritedChatType),
             agentSessionId,
@@ -1178,8 +1173,7 @@ export class SessionManager {
             createdAt: Date.now(),
             updatedAt: Date.now(),
         };
-        this.appendMeta(channel, channelId, session);
-        this.writeActive(channel, channelId, session);
+        this.persistSession(session, 'set');
         this.eventBus.publish({
             type: 'session:created',
             sessionId: session.id,
@@ -1300,4 +1294,67 @@ export class SessionManager {
         for (const adapter of this.fileAdapters.values())
             adapter.close?.();
     }
+    /**
+     * Migrate session channel key from old format "{selfPeerId}#{type}#{name}"
+     * to new format "{type}#{selfPeerId}#{name}".
+     * Runs once at startup, rewrites active.json and meta_*.jsonl in-place.
+     */
+    migrateChannelKeyFormat() {
+        const chatDirs = scanChatDirs(this.sessionsDir);
+        let migrated = 0;
+        for (const { dirPath } of chatDirs) {
+            const activePath = path.join(dirPath, 'active.json');
+            const active = readJsonFile(activePath);
+            if (!active?.channel)
+                continue;
+            const newKey = this.convertOldChannelKey(active.channel);
+            if (!newKey)
+                continue;
+            // Rewrite active.json
+            active.channel = newKey;
+            atomicWriteJson(activePath, active);
+            // Rewrite meta_*.jsonl files
+            const metaFiles = scanMetaFiles(dirPath);
+            for (const metaFile of metaFiles) {
+                const metaPath = path.join(dirPath, metaFile);
+                const lines = readAllJsonlLines(metaPath);
+                if (!lines.length)
+                    continue;
+                let changed = false;
+                for (const line of lines) {
+                    if (line.channel && this.convertOldChannelKey(line.channel)) {
+                        line.channel = this.convertOldChannelKey(line.channel);
+                        changed = true;
+                    }
+                }
+                if (changed) {
+                    const content = lines.map(l => JSON.stringify(l)).join('\n') + '\n';
+                    fs.writeFileSync(metaPath, content, 'utf-8');
+                }
+            }
+            migrated++;
+        }
+        if (migrated > 0) {
+            logger.info(`[SessionManager] Migrated ${migrated} session(s) to new channelKey format`);
+        }
+    }
+    /**
+     * Detect old format "selfPeerId#type#name" and convert to "type#selfPeerId#name".
+     * Returns null if already in new format or not a valid key.
+     */
+    convertOldChannelKey(key) {
+        const parts = key.split('#');
+        if (parts.length !== 3)
+            return null;
+        const [first, second, third] = parts;
+        // New format: type#selfPeerId#name — type is short (aun, feishu, wechat, etc.)
+        // Old format: selfPeerId#type#name — selfPeerId contains '.' (e.g., evolai.agentid.pub)
+        const knownTypes = ['aun', 'feishu', 'wechat', 'dingtalk', 'qqbot', 'wecom'];
+        if (knownTypes.includes(first))
+            return null; // already new format
+        if (knownTypes.includes(second) && first.includes('.')) {
+            return `${second}#${first}#${third}`;
+        }
+        return null;
+    }
 }