evolclaw 2.8.3 → 3.1.0

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

@@ -1,26 +1,26 @@
-import { DatabaseSync } from 'node:sqlite';
 import { DEFAULT_PERMISSION_MODE } from '../../types.js';
-import { ensureDir } from '../../config.js';
-import { resolvePaths } from '../../paths.js';
+import { ensureDir } from '../../utils/atomic-write.js';
 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 path from 'path';
+import fs from 'fs';
 import os from 'os';
 export class SessionManager {
-    db;
+    sessionsDir;
     eventBus;
     ownerResolver;
     adminResolver;
     sessionModeResolver;
     fileAdapters = new Map();
     sessionEncryptState = new Map();
-    constructor(dbPath = resolvePaths().db, eventBus, ownerResolver, adminResolver) {
-        ensureDir(path.dirname(dbPath));
-        this.db = new DatabaseSync(dbPath);
+    constructor(sessionsDir, eventBus, ownerResolver, adminResolver) {
+        ensureDir(sessionsDir);
+        this.sessionsDir = sessionsDir;
         this.eventBus = eventBus;
         this.ownerResolver = ownerResolver;
         this.adminResolver = adminResolver;
-        this.initDatabase();
     }
     setOwnerResolver(resolver) {
         this.ownerResolver = resolver;
@@ -31,8 +31,10 @@ export class SessionManager {
     setSessionModeResolver(resolver) {
         this.sessionModeResolver = resolver;
     }
-    /** 解析默认 sessionMode：通道配置锁定 > chatType 默认 > 'interactive' */
-    resolveDefaultSessionMode(channel, chatType) {
+    resolveDefaultSessionMode(channel, chatType, peerType) {
+        // 非 human 对端（ai/bot）强制 proactive，无视 agent 的默认 chatmode 配置
+        if (peerType && peerType !== 'human' && peerType !== 'unknown')
+            return 'proactive';
         const ct = chatType || 'private';
         const resolved = this.sessionModeResolver?.(channel, ct);
         return resolved || 'interactive';
@@ -44,9 +46,6 @@ export class SessionManager {
     getFileAdapter(agentId) {
         return this.fileAdapters.get(agentId);
     }
-    getDatabase() {
-        return this.db;
-    }
     getProjectDirName(projectPath) {
         return encodePath(projectPath);
     }
@@ -55,27 +54,6 @@ export class SessionManager {
         const encodedPath = this.getProjectDirName(projectPath);
         return path.join(homeDir, '.claude', 'projects', encodedPath, `${sessionId}.jsonl`);
     }
-    rowToSession(row) {
-        const metadata = row.metadata ? JSON.parse(row.metadata) : undefined;
-        return {
-            id: row.id,
-            channel: row.channel,
-            channelId: row.channel_id,
-            projectPath: row.project_path,
-            threadId: row.thread_id || '',
-            agentId: row.agent_id || 'claude',
-            chatType: row.chat_type || 'private',
-            sessionMode: row.session_mode || 'interactive',
-            agentSessionId: row.agent_session_id,
-            metadata,
-            name: row.name,
-            processingState: row.processing_state || undefined,
-            createdAt: row.created_at,
-            updatedAt: row.updated_at,
-            deletedAt: row.deleted_at ?? undefined,
-        };
-    }
-    /** 根据 userId 计算身份 */
     resolveIdentity(channel, userId) {
         if (!userId)
             return { role: 'anonymous', mode: 'interactive' };
@@ -85,58 +63,9 @@ export class SessionManager {
             return { role: 'admin', mode: 'interactive' };
         return { role: 'guest', mode: 'interactive' };
     }
-    /** 更新 session 的 identity（owner 绑定后调用） */
     async updateIdentity(sessionId, identity) {
-        // identity 不持久化到 DB，仅更新内存中的返回值
-        // 调用方应直接修改持有的 session 对象
         logger.debug(`[SessionManager] updateIdentity: sessionId=${sessionId}, role=${identity.role}`);
     }
-    /** 取消所有活跃会话（通过 metadata.isActive） */
-    deactivateAllMetadata(channel, channelId) {
-        const rows = this.db.prepare(`
-      SELECT id, metadata FROM sessions
-      WHERE channel = ? AND channel_id = ? AND json_extract(metadata, '$.isActive') = true
-    `).all(channel, channelId);
-        for (const row of rows) {
-            const metadata = row.metadata ? JSON.parse(row.metadata) : {};
-            metadata.isActive = false;
-            this.db.prepare(`
-        UPDATE sessions SET metadata = ?, updated_at = ? WHERE id = ?
-      `).run(JSON.stringify(metadata), Date.now(), row.id);
-        }
-    }
-    /** 获取当前活跃 session 的 chatType（用于新建 session 时继承） */
-    getActiveChatType(channel, channelId) {
-        const row = this.db.prepare(`
-      SELECT chat_type FROM sessions
-      WHERE channel = ? AND channel_id = ? AND json_extract(metadata, '$.isActive') = true AND thread_id = '' AND deleted_at IS NULL
-      ORDER BY updated_at DESC LIMIT 1
-    `).get(channel, channelId);
-        return row?.chat_type || 'private';
-    }
-    validateSessionFile(row) {
-        const agentSessionId = row.agent_session_id;
-        if (!agentSessionId)
-            return undefined;
-        const agentId = row.agent_id || 'claude';
-        const adapter = this.getFileAdapter(agentId);
-        if (!adapter) {
-            // 无适配器：无法验证文件，信任 DB 记录
-            return agentSessionId;
-        }
-        if (adapter.checkExists(row.project_path, agentSessionId)) {
-            return agentSessionId;
-        }
-        logger.warn(`Session file not found for ${agentId}: ${agentSessionId}, clearing session ID`);
-        this.db.prepare(`UPDATE sessions SET agent_session_id = NULL WHERE id = ?`).run(row.id);
-        return undefined;
-    }
-    insertSession(session) {
-        this.db.prepare(`
-      INSERT OR IGNORE INTO sessions (id, channel, channel_id, project_path, thread_id, agent_id, chat_type, session_mode, agent_session_id, name, created_at, updated_at, metadata)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(session.id, session.channel, session.channelId, session.projectPath, session.threadId || '', session.agentId || 'claude', session.chatType || 'private', session.sessionMode || 'interactive', session.agentSessionId ?? null, session.name ?? null, session.createdAt, session.updatedAt, session.metadata ? JSON.stringify(session.metadata) : null);
-    }
     extractUserMessageText(messageContent) {
         if (typeof messageContent === 'string') {
             const text = messageContent.trim().replace(/\s+/g, ' ');
@@ -151,306 +80,290 @@ export class SessionManager {
         }
         return null;
     }
-    initDatabase() {
-        const tableInfo = this.db.prepare('PRAGMA table_info(sessions)').all();
-        const hasIsActive = tableInfo.some((col) => col.name === 'is_active');
-        const hasName = tableInfo.some((col) => col.name === 'name');
-        const hasThreadId = tableInfo.some((col) => col.name === 'thread_id');
-        const hasAgentType = tableInfo.some((col) => col.name === 'agent_type');
-        const hasAgentId = tableInfo.some((col) => col.name === 'agent_id');
-        const hasAgentSessionId = tableInfo.some((col) => col.name === 'agent_session_id');
-        const hasMetadata = tableInfo.some((col) => col.name === 'metadata');
-        const hasIsGroup = tableInfo.some((col) => col.name === 'is_group');
-        const hasChatType = tableInfo.some((col) => col.name === 'chat_type');
-        const hasSessionMode = tableInfo.some((col) => col.name === 'session_mode');
-        const hasDeletedAt = tableInfo.some((col) => col.name === 'deleted_at');
-        // 检测是否需要 schema 重构迁移（旧字段存在，新字段不存在）
-        const needsSchemaRefactor = tableInfo.length > 0 && (hasIsGroup || hasIsActive || hasAgentType) && (!hasChatType || !hasAgentId || !hasSessionMode);
-        // Schema 重构迁移：is_group → chat_type, agent_type → agent_id, 移除 is_active
-        if (needsSchemaRefactor) {
-            logger.info('Migrating database schema (session model refactor)...');
-            this.db.exec(`DROP TABLE IF EXISTS sessions_new`);
-            this.db.exec(`
-        CREATE TABLE sessions_new (
-          id TEXT PRIMARY KEY,
-          channel TEXT NOT NULL,
-          channel_id TEXT NOT NULL,
-          agent_id TEXT NOT NULL DEFAULT 'claude',
-          thread_id TEXT NOT NULL DEFAULT '',
-          chat_type TEXT NOT NULL DEFAULT 'private',
-          session_mode TEXT NOT NULL DEFAULT 'interactive',
-          project_path TEXT NOT NULL,
-          agent_session_id TEXT,
-          name TEXT,
-          created_at INTEGER NOT NULL,
-          updated_at INTEGER NOT NULL,
-          metadata TEXT,
-          deleted_at INTEGER
-        )
-      `);
-            // 迁移数据：is_group → chat_type, agent_type → agent_id
-            this.db.exec(`
-        INSERT INTO sessions_new (id, channel, channel_id, agent_id, thread_id, chat_type, session_mode, project_path, agent_session_id, name, created_at, updated_at, metadata, deleted_at)
-        SELECT
-          id,
-          channel,
-          channel_id,
-          COALESCE(agent_type, 'claude'),
-          COALESCE(thread_id, ''),
-          CASE WHEN is_group = 1 THEN 'group' ELSE 'private' END,
-          'interactive',
-          project_path,
-          agent_session_id,
-          name,
-          created_at,
-          updated_at,
-          metadata,
-          deleted_at
-        FROM sessions
-      `);
-            this.db.exec(`DROP TABLE sessions`);
-            this.db.exec(`ALTER TABLE sessions_new RENAME TO sessions`);
-            // 创建新索引
-            this.db.exec(`
-        CREATE INDEX IF NOT EXISTS idx_session_space
-          ON sessions(channel, channel_id, agent_id, thread_id)
-          WHERE deleted_at IS NULL
-      `);
-            this.db.exec(`
-        CREATE INDEX IF NOT EXISTS idx_session_active
-          ON sessions(channel, channel_id)
-          WHERE deleted_at IS NULL
-      `);
-            logger.info('✓ Database migration completed (session model refactored)');
+    // ─── File I/O helpers ───
+    /**
+     * 解析 chat 目录路径。
+     * 1. 先扫描所有 chat 目录，按 channelId 查找匹配项（同时 channelType==channel 或缺失时直接 channelId 匹配）
+     * 2. 找不到则按 fallback：channelType=channel（实例名），selfId=null
+     *
+     * 这样保持兼容：不知道 channelType 的 caller 仍可以用 (channel, channelId) 调用。
+     */
+    resolveChatDir(channel, channelId) {
+        // 优先尝试从已有目录里找
+        const dirs = scanChatDirs(this.sessionsDir);
+        for (const d of dirs) {
+            if (d.channelId !== channelId)
+                continue;
+            // 验证 active.json 或 meta 文件里 channel（实例名）匹配
+            const active = readJsonFile(path.join(d.dirPath, 'active.json'));
+            if (active && active.channel === channel)
+                return d.dirPath;
+            // 没 active.json 时，看 channelType 是否能匹配 channel
+            if (!active && d.channelType === channel)
+                return d.dirPath;
         }
-        // ── 旧 schema 迁移（仅当旧字段存在、新字段还未迁移时运行）──
-        // 这些迁移按顺序将最旧的 schema 逐步升级到包含 is_group 的中间格式，
-        // 然后由上面的 needsSchemaRefactor 迁移一步到位转为新 schema。
-        if (!needsSchemaRefactor && tableInfo.length > 0 && hasAgentType) {
-            // 检查是否有唯一约束
-            const indexes = this.db.prepare('PRAGMA index_list(sessions)').all();
-            const hasUniqueConstraint = indexes.some((idx) => idx.origin === 'u');
-            // 迁移到新表结构（添加 thread_id, agent_type, agent_session_id, metadata）
-            if (!hasThreadId) {
-                logger.info('Migrating database schema (adding thread support)...');
-                this.db.exec(`DROP TABLE IF EXISTS sessions_new`);
-                this.db.exec(`
-          CREATE TABLE sessions_new (
-            id TEXT PRIMARY KEY,
-            channel TEXT NOT NULL,
-            channel_id TEXT NOT NULL,
-            project_path TEXT NOT NULL,
-            thread_id TEXT NOT NULL DEFAULT '',
-            agent_type TEXT NOT NULL DEFAULT 'claude',
-            agent_session_id TEXT,
-            name TEXT,
-            is_active INTEGER NOT NULL DEFAULT 0,
-            created_at INTEGER NOT NULL,
-            updated_at INTEGER NOT NULL,
-            metadata TEXT
-          );
-          INSERT INTO sessions_new (id, channel, channel_id, project_path, thread_id, agent_type, agent_session_id, name, is_active, created_at, updated_at, metadata)
-            SELECT id, channel, channel_id, project_path, '', 'claude', claude_session_id, name, is_active, created_at, updated_at, NULL FROM sessions;
-          DROP TABLE sessions;
-          ALTER TABLE sessions_new RENAME TO sessions;
-        `);
-                // 话题会话唯一约束（thread_id 非空时才生效）
-                this.db.exec(`
-          CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_thread
-            ON sessions(channel, channel_id, project_path, thread_id)
-            WHERE thread_id != ''
-        `);
-                logger.info('✓ Database migration completed (thread support added)');
-            }
-            // Migration: add is_group column
-            if (!hasIsGroup) {
-                logger.info('Migrating database schema (adding is_group)...');
-                const addIsGroupCol = 'ALTER TABLE sessions ADD COLUMN is_group INTEGER NOT NULL DEFAULT 0';
-                this.db.exec(addIsGroupCol);
-                logger.info('✓ Database migration completed (is_group added)');
-            }
-            // Reset incorrect is_group values (oc_ prefix doesn't reliably indicate group chat)
-            if (hasIsGroup) {
-                this.db.exec("UPDATE sessions SET is_group = 0 WHERE channel = 'feishu'");
-            }
-            // Migration: add deleted_at column
-            if (!hasDeletedAt) {
-                logger.info('Migrating database schema (adding deleted_at)...');
-                this.db.exec(`ALTER TABLE sessions ADD COLUMN deleted_at INTEGER`);
-                logger.info('✓ Database migration completed (deleted_at added)');
-            }
+        // Fallback：按 channel 当 channelType 创建（旧路径布局兼容）
+        return chatDirPath(this.sessionsDir, channel, channelId);
+    }
+    /**
+     * 给定明确的 channelType + selfId 时直接计算路径（不扫描）。
+     * 用于 caller 已经知道完整路由信息的场景（如 message-bridge 透传）。
+     */
+    resolveChatDirExact(channel, channelId, channelType, selfId) {
+        if (channelType) {
+            return chatDirPath(this.sessionsDir, channelType, channelId, selfId);
         }
-        // Migration: add processing_state column (独立于 schema 重构)
-        if (tableInfo.length > 0) {
-            const hasProcessingState = tableInfo.some((col) => col.name === 'processing_state');
-            if (!hasProcessingState) {
-                logger.info('Migrating database schema (adding processing_state)...');
-                this.db.exec(`ALTER TABLE sessions ADD COLUMN processing_state TEXT`);
-                logger.info('✓ Database migration completed (processing_state added)');
-            }
+        return this.resolveChatDir(channel, channelId);
+    }
+    resolveChatDirFromSession(session) {
+        const channelType = session.channelType || session.channel;
+        return chatDirPath(this.sessionsDir, channelType, session.channelId, session.selfId);
+    }
+    /** 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) {
+        const dir = this.resolveChatDir(channel, channelId);
+        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) {
+        const active = this.readActive(channel, channelId);
+        return active?.channelType || channel;
+    }
+    /** 从 active 推断 selfId（已有 session 的复用） */
+    inferSelfId(channel, channelId) {
+        const active = this.readActive(channel, channelId);
+        return active?.selfId;
+    }
+    readActive(channel, channelId) {
+        const dir = this.resolveChatDir(channel, channelId);
+        const file = readJsonFile(path.join(dir, 'active.json'));
+        if (!file)
+            return undefined;
+        return fileToSession(file);
+    }
+    writeActive(channel, channelId, session) {
+        const dir = this.ensureChatDirForSession(session);
+        const file = sessionToFile(session);
+        atomicWriteJson(path.join(dir, 'active.json'), file);
+    }
+    clearActive(channel, channelId) {
+        const dir = this.resolveChatDir(channel, channelId);
+        const activePath = path.join(dir, 'active.json');
+        try {
+            fs.unlinkSync(activePath);
         }
-        // Migration: normalize legacy metadata rootId → replyContext
-        if (hasMetadata && tableInfo.length > 0) {
-            const rows = this.db.prepare(`SELECT id, metadata FROM sessions WHERE metadata IS NOT NULL AND metadata != ''`).all();
-            let migrated = 0;
-            for (const row of rows) {
-                try {
-                    const meta = JSON.parse(row.metadata);
-                    const rootId = meta.feishu?.rootId ?? meta.threadRootId ?? meta.replyOpts?.rootId;
-                    if (!rootId && !meta.feishu && !meta.threadRootId && !meta.replyOpts)
-                        continue;
-                    // Generate replyContext from rootId if missing
-                    if (rootId && !meta.replyContext) {
-                        meta.replyContext = { replyToMessageId: rootId, replyInThread: true };
-                    }
-                    // Clean up all legacy fields
-                    delete meta.feishu;
-                    delete meta.threadRootId;
-                    delete meta.replyOpts;
-                    this.db.prepare('UPDATE sessions SET metadata = ? WHERE id = ?')
-                        .run(JSON.stringify(meta), row.id);
-                    migrated++;
-                }
-                catch { /* skip malformed JSON */ }
-            }
-            if (migrated > 0) {
-                logger.info(`✓ Migrated ${migrated} session(s): rootId normalized to replyContext`);
-            }
+        catch (e) {
+            if (e.code !== 'ENOENT')
+                throw e;
         }
-        // Migration: readonly 模式已禁用，历史会话统一转为 auto
-        if (hasMetadata && tableInfo.length > 0) {
-            const rows = this.db.prepare(`SELECT id, metadata FROM sessions WHERE metadata IS NOT NULL AND metadata != ''`).all();
-            let migratedPerm = 0;
-            for (const row of rows) {
-                try {
-                    const meta = JSON.parse(row.metadata);
-                    if (meta.permissionMode === 'readonly' || meta.permissionMode === 'noask') {
-                        meta.permissionMode = 'auto';
-                        this.db.prepare('UPDATE sessions SET metadata = ? WHERE id = ?')
-                            .run(JSON.stringify(meta), row.id);
-                        migratedPerm++;
-                    }
-                }
-                catch { /* skip malformed JSON */ }
-            }
-            if (migratedPerm > 0) {
-                logger.info(`✓ Migrated ${migratedPerm} session(s): permissionMode → auto`);
+    }
+    ensureChatDirForSession(session) {
+        const channelType = session.channelType || session.channel;
+        return ensureChatDir(this.sessionsDir, channelType, session.channelId, session.selfId);
+    }
+    metaFilePath(chatDir, sessionId) {
+        return path.join(chatDir, `${sessionId}.jsonl`);
+    }
+    appendMeta(channel, channelId, 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);
+    }
+    /**
+     * 比较两个 SessionFile 是否在内容上相等（忽略 updatedAt / updatedAtStr）。
+     * 用于跳过"没真变化"的写入，避免 jsonl 写放大。
+     */
+    sessionFilesEqual(a, b) {
+        const stripVolatile = ({ updatedAt, updatedAtStr, ...rest }) => rest;
+        return JSON.stringify(stripVolatile(a)) === JSON.stringify(stripVolatile(b));
+    }
+    /**
+     * Append meta + write active.json，但只在 session 内容（除 updatedAt 外）真正变化时才写。
+     * prev 是修改前的快照（用于 diff），next 是修改后的 session。
+     * 返回是否发生了写入。
+     */
+    writeSessionIfChanged(channel, channelId, prev, next) {
+        if (prev) {
+            const prevFile = sessionToFile(prev);
+            const nextFile = sessionToFile(next);
+            if (this.sessionFilesEqual(prevFile, nextFile))
+                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;
             }
+            this.writeActive(channel, channelId, next);
         }
-        // 创建新表（首次初始化）
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS sessions (
-        id TEXT PRIMARY KEY,
-        channel TEXT NOT NULL,
-        channel_id TEXT NOT NULL,
-        agent_id TEXT NOT NULL DEFAULT 'claude',
-        thread_id TEXT NOT NULL DEFAULT '',
-        chat_type TEXT NOT NULL DEFAULT 'private',
-        session_mode TEXT NOT NULL DEFAULT 'interactive',
-        project_path TEXT NOT NULL,
-        agent_session_id TEXT,
-        name TEXT,
-        processing_state TEXT,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL,
-        metadata TEXT,
-        deleted_at INTEGER
-      )
-    `);
-        // 会话空间索引（查询优化，无唯一约束）
-        this.db.exec(`
-      CREATE INDEX IF NOT EXISTS idx_session_space
-        ON sessions(channel, channel_id, agent_id, thread_id)
-        WHERE deleted_at IS NULL
-    `);
-        this.db.exec(`
-      CREATE INDEX IF NOT EXISTS idx_session_active
-        ON sessions(channel, channel_id)
-        WHERE deleted_at IS NULL
-    `);
-        // 创建消息去重表
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS processed_messages (
-        message_id TEXT PRIMARY KEY,
-        channel TEXT NOT NULL,
-        channel_id TEXT NOT NULL,
-        processed_at INTEGER NOT NULL
-      );
-      CREATE INDEX IF NOT EXISTS idx_processed_at ON processed_messages(processed_at);
-    `);
-        // 创建会话健康状态表
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS session_health (
-        session_id TEXT PRIMARY KEY,
-        consecutive_errors INTEGER NOT NULL DEFAULT 0,
-        last_error TEXT,
-        last_error_type TEXT,
-        safe_mode INTEGER NOT NULL DEFAULT 0,
-        last_success_time INTEGER NOT NULL,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL,
-        FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
-      );
-      CREATE INDEX IF NOT EXISTS idx_session_health_safe_mode ON session_health(safe_mode);
-    `);
+        return true;
+    }
+    readMetaLatest(metaFilePath) {
+        const file = readLastJsonlLine(metaFilePath);
+        if (!file)
+            return undefined;
+        return fileToSession(file);
     }
     /**
-     * 启动时迁移：将 sessions.channel 从 channelType 回填为实例名（channelName）。
-     * 读取每行 metadata.channelName，若与 channel 列不同则更新。
+     * 为 by-sessionId 改方法加载"当前 session 状态"。
+     *
+     * 设计契约（docs/refactor/01-db-to-fs.md）：
+     *   active.json 是热路径权威源。.jsonl 是历史档案。
+     *
+     * 读取策略：
+     *   1. 先按 sessionId 定位 .jsonl 文件（确认 session 存在 + 拿到 channel/channelId）
+     *   2. 优先读 active.json（如果 active.id === sessionId）—— 当前状态
+     *   3. 否则 fallback 到 .jsonl 末行 —— 非活跃 session 的更新（如多 session 并存时改非 active 那个）
+     *
+     * 返回 { current, prev }：
+     *   - current 用于 caller 修改后写回
+     *   - prev 是 current 的初始快照（用于 writeSessionIfChanged 的 diff 检查）
      */
-    migrateChannelToInstanceName() {
-        const rows = this.db.prepare(`SELECT id, channel, metadata FROM sessions WHERE metadata IS NOT NULL AND metadata != ''`).all();
-        let migrated = 0;
-        for (const row of rows) {
-            try {
-                const meta = JSON.parse(row.metadata);
-                if (meta.channelName && meta.channelName !== row.channel) {
-                    this.db.prepare(`UPDATE sessions SET channel = ?, updated_at = ? WHERE id = ?`)
-                        .run(meta.channelName, Date.now(), row.id);
-                    migrated++;
-                    logger.info(`[Migration] Restored channel '${row.channel}' -> '${meta.channelName}' (session ${row.id})`);
-                }
+    loadSessionForUpdate(sessionId) {
+        const found = this.findSessionFileById(sessionId);
+        if (!found)
+            return undefined;
+        // 先读 .jsonl 末行拿 channel/channelId（active.json 文件路径需要这两个）
+        const fromJsonl = this.readMetaLatest(found.metaPath);
+        if (!fromJsonl)
+            return undefined;
+        // 优先用 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 };
+    }
+    validateSessionFile(session) {
+        const agentSessionId = session.agentSessionId;
+        if (!agentSessionId)
+            return undefined;
+        const agentId = session.agentId || 'claude';
+        const adapter = this.getFileAdapter(agentId);
+        if (!adapter)
+            return agentSessionId;
+        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);
+        return undefined;
+    }
+    getActiveChatType(channel, channelId) {
+        const active = this.readActive(channel, channelId);
+        if (active && !active.threadId)
+            return active.chatType || 'private';
+        return 'private';
+    }
+    findAllSessionsInChat(chatDir, includeThreads = true) {
+        const metaFiles = scanMetaFiles(chatDir);
+        const results = [];
+        for (const metaFile of metaFiles) {
+            const session = this.readMetaLatest(path.join(chatDir, metaFile));
+            if (session)
+                results.push(session);
+        }
+        if (includeThreads) {
+            const threadsDir = path.join(chatDir, '_threads');
+            const threadMetas = scanMetaFiles(threadsDir);
+            for (const metaFile of threadMetas) {
+                const session = this.readMetaLatest(path.join(threadsDir, metaFile));
+                if (session)
+                    results.push(session);
             }
-            catch { /* skip invalid metadata */ }
         }
-        if (migrated > 0) {
-            logger.info(`Channel instance name migration completed (${migrated} sessions updated)`);
+        return results;
+    }
+    findSessionFileById(sessionId) {
+        const chatDirs = scanChatDirs(this.sessionsDir);
+        for (const { dirPath } of chatDirs) {
+            const mainPath = path.join(dirPath, `${sessionId}.jsonl`);
+            try {
+                fs.statSync(mainPath);
+                return { chatDir: dirPath, metaPath: mainPath, isThread: false };
+            }
+            catch { }
+            const threadPath = path.join(dirPath, '_threads', `${sessionId}.jsonl`);
+            try {
+                fs.statSync(threadPath);
+                return { chatDir: dirPath, metaPath: threadPath, isThread: true };
+            }
+            catch { }
         }
+        return undefined;
     }
-    /**
-     * 获取指定渠道所有已知的 thread_id（用于重启后预填充 seenThreads）
-     */
+    // ─── Public API ───
     getKnownThreadIds(channel) {
-        const rows = this.db.prepare(`
-      SELECT DISTINCT thread_id FROM sessions
-      WHERE channel = ? AND thread_id != '' AND deleted_at IS NULL
-    `).all(channel);
-        return rows.map(r => r.thread_id);
+        const chatDirs = scanChatDirs(this.sessionsDir);
+        const threadIds = [];
+        for (const { dirPath } of chatDirs) {
+            const active = readJsonFile(path.join(dirPath, 'active.json'));
+            const matchInstance = active?.channel === channel;
+            // 也兼容没 active.json 时按目录顶层 channelType 匹配（fallback 路径布局）
+            if (!matchInstance)
+                continue;
+            const index = readThreadIndex(dirPath);
+            for (const tid of Object.keys(index))
+                threadIds.push(tid);
+        }
+        return threadIds;
     }
-    /**
-     * 标记会话为处理中（实时写 DB，crash 也能恢复）
-     * processing_state 格式: "timestamp:taskId"
-     */
     markProcessing(sessionId, taskId) {
         const now = Date.now();
         const state = taskId ? `${now}:${taskId}` : String(now);
-        this.db.prepare(`UPDATE sessions SET processing_state = ?, updated_at = ? WHERE id = ?`)
-            .run(state, now, sessionId);
+        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;
+            }
+        }
     }
-    /** 从 processing_state 解析当前活跃 taskId */
     getActiveTaskId(sessionId) {
-        const row = this.db.prepare(`SELECT processing_state FROM sessions WHERE id = ?`).get(sessionId);
-        if (!row?.processing_state)
-            return undefined;
-        const colonIdx = row.processing_state.indexOf(':');
-        return colonIdx > 0 ? row.processing_state.slice(colonIdx + 1) : undefined;
+        const chatDirs = scanChatDirs(this.sessionsDir);
+        for (const { dirPath } of chatDirs) {
+            const active = readJsonFile(path.join(dirPath, 'active.json'));
+            if (active && active.id === sessionId) {
+                if (!active.activeTask)
+                    return undefined;
+                const colonIdx = active.activeTask.indexOf(':');
+                return colonIdx > 0 ? active.activeTask.slice(colonIdx + 1) : undefined;
+            }
+        }
+        return undefined;
     }
-    /**
-     * 清除会话处理中状态
-     */
     clearProcessing(sessionId) {
-        this.db.prepare(`UPDATE sessions SET processing_state = NULL, updated_at = ? WHERE id = ?`)
-            .run(Date.now(), 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;
+            }
+        }
         this.sessionEncryptState.delete(sessionId);
     }
     setSessionEncrypt(sessionId, encrypted) {
@@ -459,152 +372,140 @@ export class SessionManager {
     getSessionEncrypt(sessionId) {
         return this.sessionEncryptState.get(sessionId);
     }
-    /**
-     * 获取所有处于 processing 状态的会话（用于重启后恢复）
-     * @param maxAgeMs 最大存活时间（超过则视为超时，清除状态）默认 1 小时
-     */
     getPendingProcessingSessions(maxAgeMs = 60 * 60 * 1000) {
-        const rows = this.db.prepare(`
-      SELECT * FROM sessions
-      WHERE processing_state IS NOT NULL AND deleted_at IS NULL
-    `).all();
         const now = Date.now();
         const result = [];
-        for (const row of rows) {
-            const colonIdx = row.processing_state.indexOf(':');
-            const ts = parseInt(colonIdx > 0 ? row.processing_state.slice(0, colonIdx) : row.processing_state, 10);
+        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(this.rowToSession(row));
+                result.push(fileToSession(active));
             }
             else {
-                // 超时：清除过期状态
-                this.db.prepare(`UPDATE sessions SET processing_state = NULL WHERE id = ?`)
-                    .run(row.id);
+                active.activeTask = null;
+                active.updatedAt = now;
+                active.updatedAtStr = formatTimestamp(now);
+                atomicWriteJson(path.join(dirPath, 'active.json'), active);
             }
         }
         return result;
     }
-    async getOrCreateSession(channel, channelId, defaultProjectPath, threadId, metadata, name, userId, chatType, agentId) {
-        // 话题会话：独立查找/创建
+    // ─── Session lifecycle ───
+    async getOrCreateSession(channel, channelId, defaultProjectPath, threadId, metadata, name, userId, chatType, agentId, selfId, channelType, peerType) {
         if (threadId) {
-            const session = this.getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, agentId);
+            const session = this.getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, agentId, selfId, channelType, peerType);
             session.identity = this.resolveIdentity(channel, userId);
-            // 新话题会话补写默认权限模式
             if (session.metadata && !session.metadata.permissionMode) {
                 session.metadata.permissionMode = DEFAULT_PERMISSION_MODE;
-                this.db.prepare(`UPDATE sessions SET metadata = ?, updated_at = ? WHERE id = ?`)
-                    .run(JSON.stringify(session.metadata), Date.now(), session.id);
+                this.appendMeta(channel, channelId, session);
             }
             return session;
         }
-        // 主会话：查找活跃会话
-        const active = this.db.prepare(`
-      SELECT * FROM sessions
-      WHERE channel = ? AND channel_id = ? AND json_extract(metadata, '$.isActive') = true AND thread_id = '' AND deleted_at IS NULL
-    `).get(channel, channelId);
-        if (active) {
+        // 使用精确路径解析（caller 提供了 channelType 时直接定位，避免扫描回落）
+        const exactDir = this.resolveChatDirExact(channel, channelId, channelType, selfId);
+        const activeFile = readJsonFile(path.join(exactDir, 'active.json'));
+        const active = activeFile ? fileToSession(activeFile) : undefined;
+        if (active && !active.threadId) {
             const validSessionId = this.validateSessionFile(active);
-            const session = { ...this.rowToSession(active), agentSessionId: validSessionId };
+            const session = { ...active, agentSessionId: validSessionId };
             session.identity = this.resolveIdentity(channel, userId);
-            // chatType 自动修正：入站 chatType 与存储值不一致时更新（修复历史 session 因错误识别留下的脏数据）
+            let mutated = false;
             if (chatType && session.chatType !== chatType) {
                 logger.info(`[SessionManager] Updating chatType for session ${session.id}: ${session.chatType} -> ${chatType}`);
-                this.db.prepare(`UPDATE sessions SET chat_type = ?, updated_at = ? WHERE id = ?`)
-                    .run(chatType, Date.now(), active.id);
                 session.chatType = chatType;
+                mutated = true;
+            }
+            if (selfId && session.selfId !== selfId) {
+                session.selfId = selfId;
+                mutated = true;
             }
-            // 补写 peerId/peerName/channelName（旧 session 可能在这些字段引入前创建）
             if (chatType === 'private' && userId) {
-                const activeMeta = active.metadata ? JSON.parse(active.metadata) : {};
-                let updated = false;
-                if (!activeMeta.peerId) {
-                    activeMeta.peerId = userId;
-                    updated = true;
+                if (!session.metadata)
+                    session.metadata = {};
+                if (!session.metadata.peerId) {
+                    session.metadata.peerId = userId;
+                    mutated = true;
                 }
-                if (!activeMeta.peerName && metadata?.peerName) {
-                    activeMeta.peerName = metadata.peerName;
-                    updated = true;
+                if (!session.metadata.peerName && metadata?.peerName) {
+                    session.metadata.peerName = metadata.peerName;
+                    mutated = true;
                 }
-                if (metadata?.channelName && activeMeta.channelName !== metadata.channelName) {
-                    activeMeta.channelName = metadata.channelName;
-                    updated = true;
-                }
-                if (updated) {
-                    this.db.prepare(`UPDATE sessions SET metadata = ?, updated_at = ? WHERE id = ?`)
-                        .run(JSON.stringify(activeMeta), Date.now(), active.id);
-                    session.metadata = activeMeta;
+                if (metadata?.channelName && session.metadata.channelName !== metadata.channelName) {
+                    session.metadata.channelName = metadata.channelName;
+                    mutated = true;
                 }
             }
-            // 补写 channelName（非私聊时也需要）
             if (metadata?.channelName && chatType !== 'private') {
-                const activeMeta = active.metadata ? JSON.parse(active.metadata) : {};
-                if (activeMeta.channelName !== metadata.channelName) {
-                    activeMeta.channelName = metadata.channelName;
-                    this.db.prepare(`UPDATE sessions SET metadata = ?, updated_at = ? WHERE id = ?`)
-                        .run(JSON.stringify(activeMeta), Date.now(), active.id);
-                    session.metadata = activeMeta;
+                if (!session.metadata)
+                    session.metadata = {};
+                if (session.metadata.channelName !== metadata.channelName) {
+                    session.metadata.channelName = metadata.channelName;
+                    mutated = true;
                 }
             }
+            if (mutated) {
+                session.updatedAt = Date.now();
+                this.appendMeta(channel, channelId, session);
+                this.writeActive(channel, channelId, session);
+            }
             return session;
         }
-        // 查找默认项目的主会话
-        const existing = this.db.prepare(`
-      SELECT * FROM sessions
-      WHERE channel = ? AND channel_id = ? AND project_path = ? AND thread_id = '' AND deleted_at IS NULL
-      ORDER BY updated_at DESC LIMIT 1
-    `).get(channel, channelId, defaultProjectPath);
+        // Find existing session for default project path
+        const chatDir = this.resolveChatDir(channel, channelId);
+        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 existingMeta = existing.metadata ? JSON.parse(existing.metadata) : {};
-            existingMeta.isActive = true;
-            // chatType 自动修正（同 active 分支）
-            const shouldUpdateChatType = chatType !== undefined && existing.chat_type !== chatType;
-            if (shouldUpdateChatType) {
-                logger.info(`[SessionManager] Updating chatType for session ${existing.id}: ${existing.chat_type} -> ${chatType}`);
-                existing.chat_type = chatType;
-            }
-            // 补写 peerId/peerName
-            if (chatType === 'private' && userId && !existingMeta.peerId) {
-                existingMeta.peerId = userId;
+            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 (chatType === 'private' && metadata?.peerName && !existingMeta.peerName) {
-                existingMeta.peerName = metadata.peerName;
+            if (chatType && session.chatType !== chatType) {
+                logger.info(`[SessionManager] Updating chatType for session ${session.id}: ${session.chatType} -> ${chatType}`);
+                session.chatType = chatType;
             }
-            if (shouldUpdateChatType) {
-                this.db.prepare(`UPDATE sessions SET metadata = ?, updated_at = ?, chat_type = ? WHERE id = ?`)
-                    .run(JSON.stringify(existingMeta), Date.now(), chatType, existing.id);
+            if (chatType === 'private' && userId && !session.metadata.peerId) {
+                session.metadata.peerId = userId;
             }
-            else {
-                this.db.prepare(`UPDATE sessions SET metadata = ?, updated_at = ? WHERE id = ?`)
-                    .run(JSON.stringify(existingMeta), Date.now(), existing.id);
+            if (chatType === 'private' && metadata?.peerName && !session.metadata.peerName) {
+                session.metadata.peerName = metadata.peerName;
             }
-            const session = { ...this.rowToSession(existing), agentSessionId: validSessionId, metadata: existingMeta };
-            session.identity = this.resolveIdentity(channel, userId);
+            this.writeSessionIfChanged(channel, channelId, prev, session);
             return session;
         }
-        // 创建新主会话
-        const sessionMetadata = { ...metadata, isActive: true };
+        // Create new session
+        const sessionMetadata = { ...(metadata || {}) };
+        if (!sessionMetadata.permissionMode)
+            sessionMetadata.permissionMode = DEFAULT_PERMISSION_MODE;
         const session = {
-            id: `${channel}-${channelId}-${Date.now()}`,
+            id: generateSessionId(),
             channel,
+            channelType: channelType || channel,
             channelId,
+            selfId,
             projectPath: defaultProjectPath,
             threadId: '',
             agentId: agentId || 'claude',
             chatType: chatType || 'private',
-            sessionMode: this.resolveDefaultSessionMode(channel, chatType || 'private'),
+            sessionMode: this.resolveDefaultSessionMode(channel, chatType || 'private', peerType),
             metadata: sessionMetadata,
             name: name || '默认会话',
             createdAt: Date.now(),
-            updatedAt: Date.now()
+            updatedAt: Date.now(),
         };
         session.identity = this.resolveIdentity(channel, userId);
-        // 写入默认权限模式（统一 bypass，只在首次创建时设置）
-        if (!sessionMetadata.permissionMode) {
-            sessionMetadata.permissionMode = DEFAULT_PERMISSION_MODE;
-        }
-        this.insertSession(session);
+        this.appendMeta(channel, channelId, session);
+        this.writeActive(channel, channelId, session);
         this.eventBus.publish({
             type: 'session:created',
             sessionId: session.id,
@@ -613,81 +514,67 @@ export class SessionManager {
             projectPath: defaultProjectPath,
             name: session.name,
             chatType: session.chatType,
-            timestamp: Date.now()
+            timestamp: Date.now(),
         });
         return session;
     }
     async updateSession(sessionId, updates) {
-        const sets = [];
-        const values = [];
-        if (updates.chatType !== undefined) {
-            sets.push('chat_type = ?');
-            values.push(updates.chatType);
-        }
-        if (updates.name !== undefined) {
-            sets.push('name = ?');
-            values.push(updates.name);
-        }
-        if (updates.sessionMode !== undefined) {
-            sets.push('session_mode = ?');
-            values.push(updates.sessionMode);
-        }
-        if (updates.metadata !== undefined) {
-            sets.push('metadata = ?');
-            values.push(updates.metadata ? JSON.stringify(updates.metadata) : null);
-        }
-        if ('agentSessionId' in updates) {
-            sets.push('claude_session_id = ?');
-            values.push(updates.agentSessionId ?? null);
-        }
-        if (sets.length === 0)
+        const loaded = this.loadSessionForUpdate(sessionId);
+        if (!loaded)
             return;
-        sets.push('updated_at = ?');
-        values.push(Date.now());
-        values.push(sessionId);
-        this.db.prepare(`UPDATE sessions SET ${sets.join(', ')} WHERE id = ?`).run(...values);
-    }
-    getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, agentId) {
-        // 查找已有话题会话
-        const existing = this.db.prepare(`
-      SELECT * FROM sessions
-      WHERE channel = ? AND channel_id = ? AND thread_id = ? AND deleted_at IS NULL
-    `).get(channel, channelId, threadId);
-        if (existing) {
-            const validSessionId = this.validateSessionFile(existing);
-            // 合并 metadata（如果提供）
-            if (metadata) {
-                const existingMeta = this.rowToSession(existing).metadata;
-                const merged = existingMeta ? { ...existingMeta, ...metadata } : metadata;
-                this.db.prepare(`UPDATE sessions SET metadata = ?, updated_at = ? WHERE id = ?`)
-                    .run(JSON.stringify(merged), Date.now(), existing.id);
-                return { ...this.rowToSession(existing), agentSessionId: validSessionId, metadata: merged };
+        const { current, prev } = loaded;
+        if (updates.chatType !== undefined)
+            current.chatType = updates.chatType;
+        if (updates.name !== undefined)
+            current.name = updates.name;
+        if (updates.sessionMode !== undefined)
+            current.sessionMode = updates.sessionMode;
+        if (updates.metadata !== undefined)
+            current.metadata = updates.metadata;
+        if ('agentSessionId' in updates)
+            current.agentSessionId = updates.agentSessionId ?? undefined;
+        this.writeSessionIfChanged(current.channel, current.channelId, prev, current);
+    }
+    getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, agentId, selfId, channelType, peerType) {
+        const chatDir = this.ensureResolvedChatDir(channel, channelId);
+        const threadIndex = readThreadIndex(chatDir);
+        const existingMetaId = threadIndex[threadId];
+        if (existingMetaId) {
+            const metaPath = path.join(chatDir, '_threads', `${existingMetaId}.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);
+                }
+                return { ...existing, agentSessionId: validSessionId };
             }
-            return { ...this.rowToSession(existing), agentSessionId: validSessionId };
         }
-        // 继承当前活跃主会话的项目路径和 chatType
-        const activeMain = this.db.prepare(`
-      SELECT project_path, chat_type FROM sessions
-      WHERE channel = ? AND channel_id = ? AND json_extract(metadata, '$.isActive') = true AND thread_id = ''
-    `).get(channel, channelId);
-        const projectPath = activeMain?.project_path || defaultProjectPath;
-        // 创建新话题会话
-        const inheritedChatType = activeMain?.chat_type || 'private';
+        // Inherit project path & chatType from active main session
+        const activeMain = this.readActive(channel, channelId);
+        const projectPath = (activeMain && !activeMain.threadId ? activeMain.projectPath : undefined) || defaultProjectPath;
+        const inheritedChatType = (activeMain && !activeMain.threadId ? activeMain.chatType : undefined) || 'private';
         const session = {
-            id: `${channel}-${channelId}-${Date.now()}`,
+            id: generateSessionId(),
             channel,
+            channelType: channelType || channel,
             channelId,
+            selfId,
             projectPath,
             threadId,
             agentId: agentId || 'claude',
             chatType: inheritedChatType,
-            sessionMode: this.resolveDefaultSessionMode(channel, inheritedChatType),
+            sessionMode: this.resolveDefaultSessionMode(channel, inheritedChatType, peerType),
             metadata,
             name: name || '话题会话',
             createdAt: Date.now(),
-            updatedAt: Date.now()
+            updatedAt: Date.now(),
         };
-        this.insertSession(session);
+        this.appendMeta(channel, channelId, session);
+        threadIndex[threadId] = session.id;
+        writeThreadIndex(chatDir, threadIndex);
         this.eventBus.publish({
             type: 'session:created',
             sessionId: session.id,
@@ -695,48 +582,45 @@ export class SessionManager {
             channelId,
             projectPath,
             name: session.name,
-            timestamp: Date.now()
+            timestamp: Date.now(),
         });
         return session;
     }
     async switchProject(channel, channelId, newProjectPath, currentAgentId) {
         const agentId = currentAgentId || 'claude';
         logger.info(`[SessionManager] switchProject: channel=${channel} channelId=${channelId} newPath=${newProjectPath} agent=${agentId}`);
-        // 1. 继承当前 chatType（在 deactivate 之前读取）
         const inheritedChatType = this.getActiveChatType(channel, channelId);
-        // 2. 取消当前活跃会话
-        this.deactivateAllMetadata(channel, channelId);
-        // 3. 查找目标项目 + 当前 agent 的会话
-        const target = this.db.prepare(`
-      SELECT * FROM sessions
-      WHERE channel = ? AND channel_id = ? AND project_path = ? AND agent_id = ? AND thread_id = '' AND deleted_at IS NULL
-      ORDER BY updated_at DESC LIMIT 1
-    `).get(channel, channelId, newProjectPath, agentId);
+        const chatDir = this.ensureResolvedChatDir(channel, channelId);
+        const allSessions = this.findAllSessionsInChat(chatDir, false);
+        const target = allSessions
+            .filter(s => s.projectPath === newProjectPath && (s.agentId || 'claude') === agentId && !s.threadId)
+            .sort((a, b) => b.updatedAt - a.updatedAt)[0];
         if (target) {
             const validSessionId = this.validateSessionFile(target);
-            // 激活目标会话
-            const metadata = target.metadata ? JSON.parse(target.metadata) : {};
-            metadata.isActive = true;
-            this.db.prepare(`UPDATE sessions SET metadata = ?, updated_at = ? WHERE id = ?`)
-                .run(JSON.stringify(metadata), Date.now(), target.id);
-            return { ...this.rowToSession(target), agentSessionId: validSessionId, metadata };
+            target.agentSessionId = validSessionId;
+            target.updatedAt = Date.now();
+            this.appendMeta(channel, channelId, target);
+            this.writeActive(channel, channelId, target);
+            return target;
         }
-        // 4. 创建新会话
         const session = {
-            id: `${channel}-${channelId}-${Date.now()}`,
+            id: generateSessionId(),
             channel,
+            channelType: this.inferChannelType(channel, channelId),
             channelId,
+            selfId: this.inferSelfId(channel, channelId),
             projectPath: newProjectPath,
             threadId: '',
             agentId,
             chatType: inheritedChatType,
             sessionMode: this.resolveDefaultSessionMode(channel, inheritedChatType),
-            metadata: { isActive: true },
+            metadata: {},
             name: '默认会话',
             createdAt: Date.now(),
-            updatedAt: Date.now()
+            updatedAt: Date.now(),
         };
-        this.insertSession(session);
+        this.appendMeta(channel, channelId, session);
+        this.writeActive(channel, channelId, session);
         this.eventBus.publish({
             type: 'session:created',
             sessionId: session.id,
@@ -744,63 +628,62 @@ export class SessionManager {
             channelId,
             projectPath: newProjectPath,
             name: session.name,
-            timestamp: Date.now()
+            timestamp: Date.now(),
         });
         return session;
     }
     async updateAgentSessionId(channel, channelId, agentSessionId) {
-        // 只更新当前活跃会话的 Agent Session ID
-        this.db.prepare(`
-      UPDATE sessions
-      SET agent_session_id = ?, updated_at = ?
-      WHERE channel = ? AND channel_id = ? AND json_extract(metadata, '$.isActive') = true
-    `).run(agentSessionId, Date.now(), channel, channelId);
+        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);
     }
     async updateAgentSessionIdBySessionId(sessionId, agentSessionId) {
-        // 根据 sessionId 直接更新
-        logger.info(`[SessionManager] Updating agent_session_id: sessionId=${sessionId}, agentSessionId=${agentSessionId}`);
-        this.db.prepare(`
-      UPDATE sessions
-      SET agent_session_id = ?, updated_at = ?
-      WHERE id = ?
-    `).run(agentSessionId, Date.now(), sessionId);
+        const loaded = this.loadSessionForUpdate(sessionId);
+        if (!loaded)
+            return;
+        const { current, prev } = loaded;
+        current.agentSessionId = agentSessionId;
+        const wrote = this.writeSessionIfChanged(current.channel, current.channelId, prev, current);
+        if (wrote) {
+            logger.info(`[SessionManager] Updating agent_session_id: sessionId=${sessionId}, agentSessionId=${agentSessionId}`);
+        }
     }
     async switchAgent(channel, channelId, projectPath, newAgentId) {
-        // 1. 继承当前 chatType（在 deactivate 之前读取）
         const inheritedChatType = this.getActiveChatType(channel, channelId);
-        // 2. 取消当前活跃会话
-        this.deactivateAllMetadata(channel, channelId);
-        // 3. 查找目标 agent 在当前项目下的会话
-        const target = this.db.prepare(`
-      SELECT * FROM sessions
-      WHERE channel = ? AND channel_id = ? AND project_path = ? AND agent_id = ? AND thread_id = '' AND deleted_at IS NULL
-      ORDER BY updated_at DESC LIMIT 1
-    `).get(channel, channelId, projectPath, newAgentId);
+        const chatDir = this.ensureResolvedChatDir(channel, channelId);
+        const allSessions = this.findAllSessionsInChat(chatDir, false);
+        const target = allSessions
+            .filter(s => s.projectPath === projectPath && (s.agentId || 'claude') === newAgentId && !s.threadId)
+            .sort((a, b) => b.updatedAt - a.updatedAt)[0];
         if (target) {
             const validSessionId = this.validateSessionFile(target);
-            // 激活目标会话
-            const metadata = target.metadata ? JSON.parse(target.metadata) : {};
-            metadata.isActive = true;
-            this.db.prepare(`UPDATE sessions SET metadata = ?, updated_at = ? WHERE id = ?`)
-                .run(JSON.stringify(metadata), Date.now(), target.id);
-            return { ...this.rowToSession(target), agentSessionId: validSessionId, metadata };
+            target.agentSessionId = validSessionId;
+            target.updatedAt = Date.now();
+            this.appendMeta(channel, channelId, target);
+            this.writeActive(channel, channelId, target);
+            return target;
         }
-        // 4. 创建新会话（与 switchProject 保持一致）
         const session = {
-            id: `${channel}-${channelId}-${Date.now()}`,
+            id: generateSessionId(),
             channel,
+            channelType: this.inferChannelType(channel, channelId),
             channelId,
+            selfId: this.inferSelfId(channel, channelId),
             projectPath,
             threadId: '',
             agentId: newAgentId,
             chatType: inheritedChatType,
             sessionMode: this.resolveDefaultSessionMode(channel, inheritedChatType),
-            metadata: { isActive: true },
+            metadata: {},
             name: '默认会话',
             createdAt: Date.now(),
-            updatedAt: Date.now()
+            updatedAt: Date.now(),
         };
-        this.insertSession(session);
+        this.appendMeta(channel, channelId, session);
+        this.writeActive(channel, channelId, session);
         this.eventBus.publish({
             type: 'session:created',
             sessionId: session.id,
@@ -808,144 +691,229 @@ export class SessionManager {
             channelId,
             projectPath,
             name: session.name,
-            timestamp: Date.now()
+            timestamp: Date.now(),
         });
         return session;
     }
     async clearActiveSession(channel, channelId) {
-        // 清除当前活跃会话的 Agent Session ID
-        this.db.prepare(`
-      UPDATE sessions
-      SET agent_session_id = NULL, updated_at = ?
-      WHERE channel = ? AND channel_id = ? AND json_extract(metadata, '$.isActive') = true
-    `).run(Date.now(), channel, channelId);
-    }
-    /** 查找 owner 在目标通道的私聊 channelId（用于跨通道文件投递） */
+        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);
+    }
     getOwnerChatId(targetChannel, ownerPeerId) {
-        const row = this.db.prepare(`
-      SELECT channel_id FROM sessions
-      WHERE channel = ? AND chat_type = 'private'
-        AND json_extract(metadata, '$.peerId') = ?
-        AND deleted_at IS NULL
-      ORDER BY updated_at DESC LIMIT 1
-    `).get(targetChannel, ownerPeerId);
-        return row?.channel_id;
+        const chatDirs = scanChatDirs(this.sessionsDir);
+        let bestMatch;
+        for (const { channelId, dirPath } of chatDirs) {
+            // Check active.json first
+            const active = readJsonFile(path.join(dirPath, 'active.json'));
+            // 按 channel 实例名匹配（active.json 里有；缺失就跳过这个 chat）
+            if (!active || active.channel !== targetChannel)
+                continue;
+            const candidates = [active];
+            // Also scan meta files
+            for (const metaFile of scanMetaFiles(dirPath)) {
+                const file = readLastJsonlLine(path.join(dirPath, metaFile));
+                if (file)
+                    candidates.push(file);
+            }
+            for (const cand of candidates) {
+                if (cand.chatType !== 'private')
+                    continue;
+                if (cand.metadata?.peerId !== ownerPeerId)
+                    continue;
+                if (!bestMatch || cand.updatedAt > bestMatch.updatedAt) {
+                    bestMatch = { channelId, updatedAt: cand.updatedAt };
+                }
+            }
+        }
+        return bestMatch?.channelId;
     }
     async getSessionById(sessionId) {
-        const row = this.db.prepare('SELECT * FROM sessions WHERE id = ? AND deleted_at IS NULL').get(sessionId);
-        if (!row)
+        const found = this.findSessionFileById(sessionId);
+        if (!found)
             return undefined;
-        return this.rowToSession(row);
+        return this.readMetaLatest(found.metaPath);
     }
     async getActiveSession(channel, channelId) {
-        const row = this.db.prepare(`
-      SELECT * FROM sessions
-      WHERE channel = ? AND channel_id = ? AND json_extract(metadata, '$.isActive') = true AND deleted_at IS NULL
-    `).get(channel, channelId);
-        if (!row)
-            return undefined;
-        return this.rowToSession(row);
+        return this.readActive(channel, channelId);
     }
-    /**
-     * 查询话题会话（不创建）
-     */
     async getThreadSession(channel, channelId, threadId) {
-        const row = this.db.prepare(`
-      SELECT * FROM sessions
-      WHERE channel = ? AND channel_id = ? AND thread_id = ? AND deleted_at IS NULL
-    `).get(channel, channelId, threadId);
-        if (!row)
+        const chatDir = this.resolveChatDir(channel, channelId);
+        const threadIndex = readThreadIndex(chatDir);
+        const metaId = threadIndex[threadId];
+        if (!metaId)
+            return undefined;
+        const metaPath = path.join(chatDir, '_threads', `${metaId}.jsonl`);
+        const session = this.readMetaLatest(metaPath);
+        if (!session)
             return undefined;
-        const validSessionId = this.validateSessionFile(row);
-        return { ...this.rowToSession(row), agentSessionId: validSessionId };
+        const validSessionId = this.validateSessionFile(session);
+        return { ...session, agentSessionId: validSessionId };
     }
     async listSessions(channel, channelId) {
-        // 列出该聊天的所有会话
-        const rows = this.db.prepare(`
-      SELECT * FROM sessions
-      WHERE channel = ? AND channel_id = ? AND deleted_at IS NULL
-      ORDER BY updated_at DESC
-    `).all(channel, channelId);
-        return rows.map(row => this.rowToSession(row));
+        const chatDir = this.resolveChatDir(channel, channelId);
+        const sessions = this.findAllSessionsInChat(chatDir, true);
+        return sessions.sort((a, b) => b.updatedAt - a.updatedAt);
     }
     async getSessionByProjectPath(channel, channelId, projectPath) {
-        const row = this.db.prepare(`
-      SELECT * FROM sessions
-      WHERE channel = ? AND channel_id = ? AND project_path = ? AND deleted_at IS NULL
-      ORDER BY processing_state IS NOT NULL DESC, updated_at DESC
-      LIMIT 1
-    `).get(channel, channelId, projectPath);
-        if (!row)
+        const chatDir = this.resolveChatDir(channel, channelId);
+        const sessions = this.findAllSessionsInChat(chatDir, false);
+        const matched = sessions.filter(s => s.projectPath === projectPath);
+        if (matched.length === 0)
             return undefined;
-        return this.rowToSession(row);
+        matched.sort((a, b) => {
+            const aProc = a.processingState ? 1 : 0;
+            const bProc = b.processingState ? 1 : 0;
+            if (aProc !== bProc)
+                return bProc - aProc;
+            return b.updatedAt - a.updatedAt;
+        });
+        return matched[0];
     }
     async getSessionByName(channel, channelId, name) {
-        const row = this.db.prepare(`
-      SELECT * FROM sessions
-      WHERE channel = ? AND channel_id = ? AND name = ? AND deleted_at IS NULL
-    `).get(channel, channelId, name);
-        if (!row)
-            return undefined;
-        return this.rowToSession(row);
+        const chatDir = this.resolveChatDir(channel, channelId);
+        const sessions = this.findAllSessionsInChat(chatDir, true);
+        return sessions.find(s => s.name === name);
     }
     async switchToSession(channel, channelId, targetSessionId) {
-        // 验证目标会话存在
-        const target = this.db.prepare(`
-      SELECT * FROM sessions WHERE id = ? AND channel = ? AND channel_id = ? AND deleted_at IS NULL
-    `).get(targetSessionId, channel, channelId);
+        const chatDir = this.resolveChatDir(channel, channelId);
+        const sessions = this.findAllSessionsInChat(chatDir, true);
+        const target = sessions.find(s => s.id === targetSessionId);
         if (!target)
             return null;
-        // 取消当前活跃会话
-        this.deactivateAllMetadata(channel, channelId);
-        // 激活目标会话
-        const metadata = target.metadata ? JSON.parse(target.metadata) : {};
-        metadata.isActive = true;
-        this.db.prepare(`UPDATE sessions SET metadata = ?, updated_at = ? WHERE id = ?`)
-            .run(JSON.stringify(metadata), Date.now(), targetSessionId);
-        return { ...this.rowToSession(target), metadata, updatedAt: Date.now() };
+        target.updatedAt = Date.now();
+        this.appendMeta(channel, channelId, target);
+        this.writeActive(channel, channelId, target);
+        return target;
     }
     updateMetadata(sessionId, metadata) {
-        this.db.prepare(`UPDATE sessions SET metadata = ?, updated_at = ? WHERE id = ?`)
-            .run(JSON.stringify(metadata), Date.now(), sessionId);
+        const loaded = this.loadSessionForUpdate(sessionId);
+        if (!loaded)
+            return;
+        const { current, prev } = loaded;
+        current.metadata = metadata;
+        this.writeSessionIfChanged(current.channel, current.channelId, prev, current);
     }
     async renameSession(sessionId, newName) {
-        const result = this.db.prepare(`
-      UPDATE sessions SET name = ?, updated_at = ? WHERE id = ?
-    `).run(newName, Date.now(), sessionId);
-        return result.changes > 0;
+        const loaded = this.loadSessionForUpdate(sessionId);
+        if (!loaded)
+            return false;
+        const { current, prev } = loaded;
+        current.name = newName;
+        this.writeSessionIfChanged(current.channel, current.channelId, prev, current);
+        return true;
     }
     async unbindSession(sessionId) {
-        const result = this.db.prepare(`
-      DELETE FROM sessions WHERE id = ?
-    `).run(sessionId);
-        return result.changes > 0;
+        const found = this.findSessionFileById(sessionId);
+        if (!found)
+            return false;
+        const trashDir = path.join(found.chatDir, '_trash');
+        fs.mkdirSync(trashDir, { recursive: true });
+        const trashPath = path.join(trashDir, path.basename(found.metaPath));
+        try {
+            fs.renameSync(found.metaPath, trashPath);
+        }
+        catch (e) {
+            if (e.code !== 'ENOENT')
+                throw e;
+        }
+        // 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) {
+                    delete threadIndex[tid];
+                    break;
+                }
+            }
+            writeThreadIndex(found.chatDir, threadIndex);
+        }
+        // Clear active.json if it pointed to this session
+        const activePath = path.join(found.chatDir, 'active.json');
+        const active = readJsonFile(activePath);
+        if (active && active.id === sessionId) {
+            try {
+                fs.unlinkSync(activePath);
+            }
+            catch (e) {
+                if (e.code !== 'ENOENT')
+                    throw e;
+            }
+        }
+        return true;
     }
     async softDeleteSession(channelId) {
-        this.db.prepare(`
-      UPDATE sessions SET deleted_at = ?, updated_at = ? WHERE channel_id = ? AND deleted_at IS NULL
-    `).run(Date.now(), Date.now(), channelId);
+        const chatDirs = scanChatDirs(this.sessionsDir);
+        for (const { channelId: cid, dirPath } of chatDirs) {
+            if (cid !== channelId)
+                continue;
+            const trashDir = path.join(dirPath, '_trash');
+            fs.mkdirSync(trashDir, { recursive: true });
+            for (const metaFile of scanMetaFiles(dirPath)) {
+                const src = path.join(dirPath, metaFile);
+                const dst = path.join(trashDir, metaFile);
+                try {
+                    fs.renameSync(src, dst);
+                }
+                catch (e) {
+                    if (e.code !== 'ENOENT')
+                        throw e;
+                }
+            }
+            const threadsDir = path.join(dirPath, '_threads');
+            for (const metaFile of scanMetaFiles(threadsDir)) {
+                const src = path.join(threadsDir, metaFile);
+                const dst = path.join(trashDir, metaFile);
+                try {
+                    fs.renameSync(src, dst);
+                }
+                catch (e) {
+                    if (e.code !== 'ENOENT')
+                        throw e;
+                }
+            }
+            // Clear active.json
+            const activePath = path.join(dirPath, 'active.json');
+            try {
+                fs.unlinkSync(activePath);
+            }
+            catch (e) {
+                if (e.code !== 'ENOENT')
+                    throw e;
+            }
+            // Clear thread index
+            try {
+                fs.unlinkSync(path.join(threadsDir, 'thread-index.json'));
+            }
+            catch (e) {
+                if (e.code !== 'ENOENT')
+                    throw e;
+            }
+        }
     }
     async createNewSession(channel, channelId, projectPath, name, agentId) {
-        // 继承当前 chatType（在 deactivate 之前读取）
         const inheritedChatType = this.getActiveChatType(channel, channelId);
-        // 取消当前活跃会话
-        this.deactivateAllMetadata(channel, channelId);
-        // 创建新会话
         const session = {
-            id: `${channel}-${channelId}-${Date.now()}`,
+            id: generateSessionId(),
             channel,
+            channelType: this.inferChannelType(channel, channelId),
             channelId,
+            selfId: this.inferSelfId(channel, channelId),
             projectPath,
             threadId: '',
             agentId: agentId || 'claude',
             chatType: inheritedChatType,
             sessionMode: this.resolveDefaultSessionMode(channel, inheritedChatType),
-            metadata: { isActive: true },
+            metadata: {},
             name: name || '默认会话',
             createdAt: Date.now(),
-            updatedAt: Date.now()
+            updatedAt: Date.now(),
         };
-        this.insertSession(session);
+        this.appendMeta(channel, channelId, session);
+        this.writeActive(channel, channelId, session);
         this.eventBus.publish({
             type: 'session:created',
             sessionId: session.id,
@@ -953,32 +921,30 @@ export class SessionManager {
             channelId,
             projectPath,
             name: session.name,
-            timestamp: Date.now()
+            timestamp: Date.now(),
         });
         return session;
     }
-    /**
-     * 基于现有会话创建分支会话
-     */
     async createForkedSession(sourceSession, forkedAgentSessionId, name) {
-        // 取消当前活跃会话
-        this.deactivateAllMetadata(sourceSession.channel, sourceSession.channelId);
         const session = {
-            id: `${sourceSession.channel}-${sourceSession.channelId}-${Date.now()}`,
+            id: generateSessionId(),
             channel: sourceSession.channel,
+            channelType: sourceSession.channelType || sourceSession.channel,
             channelId: sourceSession.channelId,
+            selfId: sourceSession.selfId,
             projectPath: sourceSession.projectPath,
             threadId: sourceSession.threadId || '',
             agentId: sourceSession.agentId || 'claude',
             chatType: sourceSession.chatType || 'private',
             sessionMode: sourceSession.sessionMode || 'interactive',
             agentSessionId: forkedAgentSessionId,
-            metadata: { isActive: true },
+            metadata: {},
             name: name || `${sourceSession.name || '会话'}-分支`,
             createdAt: Date.now(),
-            updatedAt: Date.now()
+            updatedAt: Date.now(),
         };
-        this.insertSession(session);
+        this.appendMeta(sourceSession.channel, sourceSession.channelId, session);
+        this.writeActive(sourceSession.channel, sourceSession.channelId, session);
         this.eventBus.publish({
             type: 'session:created',
             sessionId: session.id,
@@ -986,7 +952,7 @@ export class SessionManager {
             channelId: sourceSession.channelId,
             projectPath: sourceSession.projectPath,
             name: session.name,
-            timestamp: Date.now()
+            timestamp: Date.now(),
         });
         return session;
     }
@@ -1014,18 +980,12 @@ export class SessionManager {
             return null;
         return adapter.readLastUserMessage(projectPath, agentSessionId);
     }
-    /**
-     * 获取会话文件信息（回合数 + 标题）
-     */
     getSessionFileInfo(projectPath, agentSessionId, agentId) {
         const adapter = this.getFileAdapter(agentId);
         if (!adapter)
             return { turns: 0 };
         return adapter.getFileInfo(projectPath, agentSessionId);
     }
-    /**
-     * 列出 SDK 侧的会话列表（用于名称同步）
-     */
     async listSdkSessions(projectPath, agentId) {
         const adapter = this.getFileAdapter(agentId);
         if (!adapter?.listSdkSessions)
@@ -1033,42 +993,39 @@ export class SessionManager {
         return adapter.listSdkSessions(projectPath);
     }
     async getSessionByUuidPrefix(channel, channelId, uuidPrefix) {
-        const rows = this.db.prepare(`
-      SELECT * FROM sessions
-      WHERE channel = ? AND channel_id = ? AND agent_session_id LIKE ? AND deleted_at IS NULL
-    `).all(channel, channelId, `${uuidPrefix}%`);
-        if (rows.length === 0)
+        const chatDir = this.resolveChatDir(channel, channelId);
+        const sessions = this.findAllSessionsInChat(chatDir, true);
+        const matched = sessions.filter(s => s.agentSessionId && s.agentSessionId.startsWith(uuidPrefix));
+        if (matched.length === 0)
             return undefined;
-        if (rows.length > 1) {
+        if (matched.length > 1) {
             logger.warn(`Multiple sessions found with UUID prefix: ${uuidPrefix}`);
         }
-        return this.rowToSession(rows[0]);
+        return matched[0];
     }
     async importCliSession(channel, channelId, projectPath, agentSessionId, agentId = 'claude') {
-        // 继承当前 chatType（在 deactivate 之前读取）
         const inheritedChatType = this.getActiveChatType(channel, channelId);
-        // 取消当前活跃会话
-        this.deactivateAllMetadata(channel, channelId);
-        // 从 CLI 会话文件读取标题
         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' })}`;
-        // 创建新会话记录
         const session = {
-            id: `${channel}-${channelId}-${Date.now()}`,
+            id: generateSessionId(),
             channel,
+            channelType: this.inferChannelType(channel, channelId),
             channelId,
+            selfId: this.inferSelfId(channel, channelId),
             projectPath,
             threadId: '',
             agentId,
             chatType: inheritedChatType,
             sessionMode: this.resolveDefaultSessionMode(channel, inheritedChatType),
             agentSessionId,
-            metadata: { isActive: true },
+            metadata: {},
             name,
             createdAt: Date.now(),
-            updatedAt: Date.now()
+            updatedAt: Date.now(),
         };
-        this.insertSession(session);
+        this.appendMeta(channel, channelId, session);
+        this.writeActive(channel, channelId, session);
         this.eventBus.publish({
             type: 'session:created',
             sessionId: session.id,
@@ -1076,111 +1033,117 @@ export class SessionManager {
             channelId,
             projectPath,
             name,
-            timestamp: Date.now()
+            timestamp: Date.now(),
         });
         return session;
     }
-    // ==================== 健康状态管理 ====================
-    /**
-     * 获取会话健康状态
-     */
+    // ─── Health status ───
+    healthFilePath(channel, channelId) {
+        return path.join(this.ensureResolvedChatDir(channel, channelId), 'health.jsonl');
+    }
+    /** Find the chat dir containing a given session id */
+    chatDirForSession(sessionId) {
+        const found = this.findSessionFileById(sessionId);
+        if (!found)
+            return undefined;
+        // 从 meta jsonl 最后一行读 channel 实例名 + channelId
+        const meta = readLastJsonlLine(found.metaPath);
+        if (!meta)
+            return undefined;
+        return { channel: meta.channel, channelId: meta.channelId, dirPath: found.chatDir };
+    }
     async getHealthStatus(sessionId) {
-        const row = this.db.prepare(`
-      SELECT * FROM session_health WHERE session_id = ?
-    `).get(sessionId);
-        if (!row) {
-            // 首次查询，创建默认记录
-            const now = Date.now();
-            this.db.prepare(`
-        INSERT INTO session_health (session_id, consecutive_errors, safe_mode, last_success_time, created_at, updated_at)
-        VALUES (?, 0, 0, ?, ?, ?)
-      `).run(sessionId, now, now, now);
-            return {
-                consecutiveErrors: 0,
-                safeMode: false,
-                lastSuccessTime: now
-            };
+        const chatInfo = this.chatDirForSession(sessionId);
+        if (!chatInfo) {
+            return { consecutiveErrors: 0, safeMode: false, lastSuccessTime: Date.now() };
         }
+        const healthPath = path.join(chatInfo.dirPath, 'health.jsonl');
+        const records = readAllJsonlLines(healthPath).filter(r => r.sessionId === sessionId);
+        let consecutiveErrors = 0;
+        let lastError;
+        let lastErrorType;
+        let lastSuccessTime = 0;
+        // Walk from tail to count consecutive errors
+        for (let i = records.length - 1; i >= 0; i--) {
+            const rec = records[i];
+            if (rec.type === 'error') {
+                consecutiveErrors++;
+                if (lastError === undefined) {
+                    lastError = rec.error;
+                    lastErrorType = rec.errorType;
+                }
+            }
+            else {
+                // success or reset breaks the streak
+                if (rec.type === 'success' && rec.at > lastSuccessTime)
+                    lastSuccessTime = rec.at;
+                break;
+            }
+        }
+        // Find most recent success time across all records
+        if (lastSuccessTime === 0) {
+            for (let i = records.length - 1; i >= 0; i--) {
+                if (records[i].type === 'success' && records[i].at > lastSuccessTime) {
+                    lastSuccessTime = records[i].at;
+                    break;
+                }
+            }
+        }
+        if (lastSuccessTime === 0)
+            lastSuccessTime = Date.now();
         return {
-            consecutiveErrors: row.consecutive_errors,
-            lastError: row.last_error,
-            lastErrorType: row.last_error_type,
-            safeMode: row.safe_mode === 1,
-            lastSuccessTime: row.last_success_time
+            consecutiveErrors,
+            lastError,
+            lastErrorType,
+            safeMode: false,
+            lastSuccessTime,
         };
     }
-    /** 当前处于安全模式的会话数 */
-    getSafeModeSessionCount() {
-        const row = this.db.prepare(`SELECT COUNT(*) as count FROM session_health WHERE safe_mode = 1`).get();
-        return row?.count ?? 0;
-    }
-    /**
-     * 记录成功响应（重置错误计数）
-     */
     async recordSuccess(sessionId) {
+        const chatInfo = this.chatDirForSession(sessionId);
+        if (!chatInfo)
+            return;
         const now = Date.now();
-        this.db.prepare(`
-      INSERT INTO session_health (session_id, consecutive_errors, safe_mode, last_success_time, created_at, updated_at)
-      VALUES (?, 0, 0, ?, ?, ?)
-      ON CONFLICT(session_id) DO UPDATE SET
-        consecutive_errors = 0,
-        last_error = NULL,
-        last_error_type = NULL,
-        last_success_time = ?,
-        updated_at = ?
-    `).run(sessionId, now, now, now, now, now);
+        const record = {
+            type: 'success',
+            sessionId,
+            at: now,
+            atStr: formatTimestamp(now),
+        };
+        appendJsonl(path.join(chatInfo.dirPath, 'health.jsonl'), record);
     }
-    /**
-     * 记录错误（增加计数）
-     */
     async recordError(sessionId, errorType, errorMessage) {
+        const chatInfo = this.chatDirForSession(sessionId);
+        if (!chatInfo)
+            return 0;
         const now = Date.now();
-        const health = await this.getHealthStatus(sessionId);
-        const newCount = health.consecutiveErrors + 1;
-        this.db.prepare(`
-      INSERT INTO session_health (session_id, consecutive_errors, last_error, last_error_type, safe_mode, last_success_time, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT(session_id) DO UPDATE SET
-        consecutive_errors = consecutive_errors + 1,
-        last_error = ?,
-        last_error_type = ?,
-        updated_at = ?
-    `).run(sessionId, newCount, errorMessage, errorType, health.safeMode ? 1 : 0, health.lastSuccessTime, now, now, errorMessage, errorType, now);
-        return newCount;
-    }
-    /**
-     * 设置安全模式
-     */
-    async setSafeMode(sessionId, enabled) {
-        const now = Date.now();
-        const health = await this.getHealthStatus(sessionId);
-        this.db.prepare(`
-      INSERT INTO session_health (session_id, consecutive_errors, safe_mode, last_success_time, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?)
-      ON CONFLICT(session_id) DO UPDATE SET
-        safe_mode = ?,
-        updated_at = ?
-    `).run(sessionId, health.consecutiveErrors, enabled ? 1 : 0, health.lastSuccessTime, now, now, enabled ? 1 : 0, now);
+        const record = {
+            type: 'error',
+            sessionId,
+            errorType,
+            error: errorMessage,
+            at: now,
+            atStr: formatTimestamp(now),
+        };
+        appendJsonl(path.join(chatInfo.dirPath, 'health.jsonl'), record);
+        const status = await this.getHealthStatus(sessionId);
+        return status.consecutiveErrors;
     }
-    /**
-     * 重置健康状态（用于修复后）
-     */
     async resetHealthStatus(sessionId) {
+        const chatInfo = this.chatDirForSession(sessionId);
+        if (!chatInfo)
+            return;
         const now = Date.now();
-        this.db.prepare(`
-      INSERT INTO session_health (session_id, consecutive_errors, safe_mode, last_success_time, created_at, updated_at)
-      VALUES (?, 0, 0, ?, ?, ?)
-      ON CONFLICT(session_id) DO UPDATE SET
-        consecutive_errors = 0,
-        last_error = NULL,
-        last_error_type = NULL,
-        safe_mode = 0,
-        updated_at = ?
-    `).run(sessionId, now, now, now, now);
+        const record = {
+            type: 'reset',
+            sessionId,
+            at: now,
+            atStr: formatTimestamp(now),
+        };
+        appendJsonl(path.join(chatInfo.dirPath, 'health.jsonl'), record);
     }
     close() {
         for (const adapter of this.fileAdapters.values())
             adapter.close?.();
-        this.db.close();
     }
 }