evolcore 0.0.33 → 0.0.35-test.0

package/dist/core/thread/thread-service.js

@@ -3,12 +3,29 @@ import fs from 'fs';
 import path from 'path';
 import { agentSessionsDir, agentDir, agentThreadIndexPath, agentThreadSummariesDir, agentThreadSummaryPath } from '../../paths.js';
 import { atomicWriteJson, atomicReadJson } from '../../utils/atomic-write.js';
-import { appendJsonl, readAllJsonlLines, readLastJsonlLineStrict, chatDirPath, tryParseChannelSessionKey } from '../session/session-fs-store.js';
-import { sanitizeSessionTitle } from '../session/session-title.js';
+import { appendJsonl, appendJsonlDurable, readAllJsonlLines, readLastJsonlLine, readLastJsonlLineStrict, chatDirPath, scanChatDirs, tryParseChannelSessionKey } from '../session/session-fs-store.js';
+import { sanitizeSessionTitle, SESSION_TITLE_MAX_LEN, SESSION_TITLE_STORED_MAX_LEN, SESSION_TITLE_ELLIPSIS } from '../session/session-title.js';
 import { ThreadContextStorage } from './thread-context-storage.js';
 const THREAD_ID_RE = /^thread-[0-9]+-[0-9a-f]{4}-[0-9a-f]{4}$/;
 const RESERVED_THREAD_IDS = new Set(['current', 'main', 'all']);
-const THREAD_NAME_MAX_LEN = 80;
+/**
+ * 话题名长度校验：自动生成与手动改名共用 `session-title.ts` 的两个常量。
+ *
+ * - `SESSION_TITLE_MAX_LEN`（80）：正文上限，`sanitizeSessionTitle` 按它截断并补省略号；
+ * - `SESSION_TITLE_STORED_MAX_LEN`（83）：80 字符正文 + `...`，落盘上限。
+ *
+ * 校验按落盘上限而不是正文上限：系统自动生成的话题名最长就是 83 字符，
+ * 按 80 拒绝会让这些名字「改不回去」。超过 83 的直接拒绝并报出当前长度，
+ * 不静默截断——让调用方以为完整名称生效了比报错更糟。
+ */
+function assertThreadNameLength(rawName, sanitized) {
+    const raw = rawName.trim();
+    if (raw.length <= SESSION_TITLE_STORED_MAX_LEN)
+        return;
+    throw new ThreadServiceError(`话题名称超过 ${SESSION_TITLE_STORED_MAX_LEN} 字符上限（当前 ${raw.length} 字符，含标点；`
+        + `其中前 ${SESSION_TITLE_MAX_LEN} 字符为正文，末尾可带 ${SESSION_TITLE_ELLIPSIS} 省略号）。`
+        + `请缩写后重试`, 'NAME_TOO_LONG');
+}
 const LIST_DEFAULT_LIMIT = 10;
 const LIST_MAX_LIMIT = 200;
 export class ThreadServiceError extends Error {
@@ -25,12 +42,41 @@ function newThreadId() {
     const rand = crypto.randomBytes(2).toString('hex');
     return `thread-${ms}-${seq}-${rand}`;
 }
+/**
+ * 读取话题索引，兼容 4d938a6f（话题数据目录收敛）之前的旧路径。
+ *
+ * 旧文件位于 `data/thread-index.json`，新路径是 `data/threads/index.json`。
+ * 那次改动只搬了路径、没写迁移，导致老 agent 的索引在新路径上不存在，
+ * 依赖索引的命令（peers / list / rename ...）看着像"没有话题"。
+ *
+ * 新索引缺失或为空时回退读旧文件，转换后写回新路径。写回是幂等的：
+ * 成功一次之后新索引存在，后续不会再走旧文件；旧文件保持原样，不删除。
+ */
 function readIndex(indexPath) {
     const raw = atomicReadJson(indexPath);
-    if (!raw || !Array.isArray(raw.threads)) {
-        return { version: 1, threads: [] };
+    if (raw && Array.isArray(raw.threads) && raw.threads.length > 0) {
+        return raw;
+    }
+    const legacyPath = path.join(path.dirname(path.dirname(indexPath)), 'thread-index.json');
+    if (legacyPath !== indexPath) {
+        const legacy = atomicReadJson(legacyPath);
+        if (legacy && Array.isArray(legacy.threads) && legacy.threads.length > 0) {
+            const migrated = {
+                version: 1,
+                threads: legacy.threads,
+            };
+            // 顺手落盘；失败不影响本次读取（例如目录只读），下次仍能走回退。
+            try {
+                fs.mkdirSync(path.dirname(indexPath), { recursive: true });
+                atomicWriteJson(indexPath, migrated);
+            }
+            catch { /* 写失败不阻断读取 */ }
+            return migrated;
+        }
     }
-    return raw;
+    if (raw && Array.isArray(raw.threads))
+        return raw;
+    return { version: 1, threads: [] };
 }
 /**
  * 把用户传入的 peer 归一成索引里实际存储的形态（对端在该渠道下的原生 ID）。
@@ -117,9 +163,7 @@ export class ThreadService {
         const sanitized = sanitizeSessionTitle(name);
         if (!sanitized)
             throw new ThreadServiceError('话题名称不能为空', 'INVALID_NAME');
-        if (sanitized.length > THREAD_NAME_MAX_LEN) {
-            throw new ThreadServiceError(`话题名称超过 ${THREAD_NAME_MAX_LEN} 字符`, 'NAME_TOO_LONG');
-        }
+        assertThreadNameLength(name, sanitized);
         // Check for duplicate name on same peer
         const index = this.readThreadIndex(selfAid);
         const dup = index.threads.find(t => t.peer === peer && t.name === sanitized);
@@ -176,8 +220,20 @@ export class ThreadService {
         const sanitized = sanitizeSessionTitle(name);
         if (!sanitized)
             throw new ThreadServiceError('话题名称不能为空', 'INVALID_NAME');
-        if (sanitized.length > THREAD_NAME_MAX_LEN) {
-            throw new ThreadServiceError(`话题名称超过 ${THREAD_NAME_MAX_LEN} 字符`, 'NAME_TOO_LONG');
+        assertThreadNameLength(name, sanitized);
+        // 主会话（threadId 为空）从不进话题索引，它由会话文件产生。
+        // 改名直接落到 active session 上，不走索引与快照。
+        // 群里主会话名只有 admin/owner 能改，且在授权层已经拦过；这里照常落本地。
+        if (!threadId) {
+            const main = await this.showMainSession(selfAid, peer);
+            if (!main)
+                throw new ThreadServiceError(`与 ${peer} 无活跃主会话`, 'TOPIC_NOT_FOUND');
+            if ((main.name ?? '') === sanitized)
+                return { changed: false, name: sanitized };
+            const renamed = await this.sessionManager.renameSession(main.sessionId, sanitized);
+            if (!renamed)
+                throw new ThreadServiceError(`主会话改名失败: ${main.sessionId}`, 'RENAME_FAILED');
+            return { changed: true, name: sanitized, nameUpdatedAt: Date.now() };
         }
         const index = this.readThreadIndex(selfAid);
         const entry = index.threads.find(t => t.peer === peer && t.threadId === threadId);
@@ -185,8 +241,10 @@ export class ThreadService {
             throw new ThreadServiceError(`话题不存在: ${threadId}`, 'TOPIC_NOT_FOUND');
         if (entry.name === sanitized)
             return { changed: false, name: sanitized };
+        const nameUpdatedAt = Date.now();
         entry.name = sanitized;
-        entry.lastActiveAt = Date.now();
+        entry.nameUpdatedAt = nameUpdatedAt;
+        entry.lastActiveAt = nameUpdatedAt;
         this.writeThreadIndex(selfAid, index);
         this.appendThreadSnapshot(selfAid, entry);
         // Sync to session
@@ -194,7 +252,50 @@ export class ThreadService {
         if (session) {
             await this.sessionManager.renameSession(session.id, sanitized);
         }
-        return { changed: true, name: sanitized };
+        return { changed: true, name: sanitized, nameUpdatedAt };
+    }
+    /**
+     * 应用对端发来的改名通知（`topic-renamed`）。
+     *
+     * 判据是最新更新时间先到先赢：通知里的 `nameUpdatedAt` 只有**严格大于**本地
+     * 记录时才生效。对端尚未建档时按通知内容建条目（与会话自动建档一致），
+     * 这样后续跨话题交互能看到对端已命名的话题。
+     */
+    async applyRemoteRename(input) {
+        const sanitized = sanitizeSessionTitle(input.name);
+        if (!sanitized || !input.threadId)
+            return { applied: false, reason: 'invalid' };
+        const peer = normalizeThreadPeer(input.peer) ?? input.peer;
+        const index = this.readThreadIndex(input.selfAid);
+        const entry = index.threads.find(t => t.peer === peer && t.threadId === input.threadId);
+        const current = entry?.nameUpdatedAt ?? 0;
+        if (input.nameUpdatedAt <= current)
+            return { applied: false, reason: 'stale' };
+        if (!entry) {
+            index.threads.push({
+                threadId: input.threadId,
+                sessionId: '',
+                peer,
+                channelType: 'aun',
+                peerKind: input.peerKind ?? 'private',
+                name: sanitized,
+                nameUpdatedAt: input.nameUpdatedAt,
+                label: null,
+                topicStatus: 'pending',
+                createdAt: input.nameUpdatedAt,
+                lastActiveAt: input.nameUpdatedAt,
+            });
+            this.writeThreadIndex(input.selfAid, index);
+            return { applied: true };
+        }
+        entry.name = sanitized;
+        entry.nameUpdatedAt = input.nameUpdatedAt;
+        this.writeThreadIndex(input.selfAid, index);
+        this.appendThreadSnapshot(input.selfAid, entry);
+        const session = await this.sessionManager.getThreadSession(entryChannelType(entry), entry.peer, input.threadId, input.selfAid);
+        if (session)
+            await this.sessionManager.renameSession(session.id, sanitized);
+        return { applied: true };
     }
     // ── P1a.1.6: 话题标签 ──
     async labelThread(input) {
@@ -237,6 +338,10 @@ export class ThreadService {
      * 活跃时间取自该对端消息日志的最后一行，读尾行（不整文件加载）；
      * 无消息日志或读取失败时退回索引里的管理动作时间。
      * 内部话题（daemon 命名空间的会话记录）不是真实联系人，不在此列。
+     *
+     * 候选集 = 索引条目 ∪ 磁盘上真实存在的 chat 目录：
+     * 主会话从不进索引（它由会话文件而非 createThread 产生），只靠索引会漏掉
+     * "只聊过主会话"的对端。磁盘扫描兜住这一类，threadCount 至少记 1。
      */
     listPeers(selfAid) {
         const index = this.readThreadIndex(selfAid);
@@ -252,6 +357,7 @@ export class ThreadService {
                     threadCount: 1,
                     lastActiveAt: entry.lastActiveAt,
                     channelType: entryChannelType(entry),
+                    indexed: true,
                 });
             }
             else {
@@ -260,6 +366,45 @@ export class ThreadService {
                     existing.lastActiveAt = entry.lastActiveAt;
             }
         }
+        // 索引之外的兜底：磁盘上真实存在、且有消息或会话存档的 chat 目录。
+        // 只加索引里没有的对端——索引已经有了的，子话题数已算过，不再重复计主会话。
+        // 从目录名解析 peer 与 channelType，避免信赖可能过期的索引字段。
+        try {
+            const agentsRoot = path.dirname(agentDir(selfAid));
+            for (const chat of scanChatDirs(agentsRoot)) {
+                if (chat.selfAID !== selfAid)
+                    continue;
+                const peer = chat.channelId;
+                if (!peer || isInternalThreadPeer(peer))
+                    continue;
+                const existing = map.get(peer);
+                if (existing) {
+                    // 索引里有的对端：只更正渠道类型（索引历史条目可能缺字段）
+                    if (!existing.channelType)
+                        existing.channelType = chat.channelType;
+                    continue;
+                }
+                // 无消息、无会话存档的空目录不算对端
+                const hasPayload = fs.existsSync(path.join(chat.dirPath, 'messages.jsonl'))
+                    || fs.existsSync(path.join(chat.dirPath, 'active.json'));
+                if (!hasPayload)
+                    continue;
+                // 用当前主会话判定群/私聊；没有会话文件时按目录名兜底为私聊
+                const active = this.sessionManager
+                    ? this.sessionManager.getActiveSessionSync(chat.channelType, peer, chat.channelType, selfAid)
+                    : undefined;
+                map.set(peer, {
+                    peerKind: active?.chatType === 'group' ? 'group' : 'private',
+                    threadCount: 1,
+                    lastActiveAt: active?.updatedAt ?? 0,
+                    channelType: chat.channelType,
+                    indexed: false,
+                });
+            }
+        }
+        catch {
+            // 扫描失败不影响索引结果
+        }
         return Array.from(map.entries())
             .map(([peer, v]) => {
             // 真实活跃时间 = 消息日志末行的时间戳。
@@ -296,6 +441,55 @@ export class ThreadService {
                 return false;
             return true;
         });
+        // 主会话是 threadId 为 `''` 的话题：它由会话文件而非 createThread 产生，
+        // 所以从不进话题索引。只列子话题会让「和某对端聊过什么」在列表里看不到主线，
+        // 而 `history <peer>` 不传 threadId 读的恰恰是主会话消息。指定对端时补一条
+        // 合成记录，让 list 与 history 的口径一致。
+        if (peer) {
+            const hasMain = threads.some(t => !t.threadId);
+            if (!hasMain) {
+                const chatDir = this.chatDirFor(selfAid, peer);
+                const logPath = path.join(chatDir, 'messages.jsonl');
+                let lastTs = 0;
+                if (fs.existsSync(logPath)) {
+                    try {
+                        for (const m of readAllJsonlLines(logPath)) {
+                            if (!m.threadId && typeof m.ts === 'number' && m.ts > lastTs)
+                                lastTs = m.ts;
+                        }
+                    }
+                    catch { /* skip corrupt file */ }
+                }
+                // 群标识与私聊 AID 语法相同，只能靠会话记录里的 chatType 判定；
+                // 没有会话文件时退回私聊（`ec thread list <peer>` 的常见用法）。
+                const active = this.sessionManager.getActiveSessionSync('aun', peer, 'aun', selfAid);
+                const peerKind = active?.chatType === 'group' ? 'group' : 'private';
+                const synthetic = {
+                    threadId: '',
+                    sessionId: active?.id ?? '',
+                    peer,
+                    channelType: 'aun',
+                    peerKind,
+                    // 主会话有自己的名字（创建时写 `默认会话`，可经 ec thread rename 修改）。
+                    // 读真实值而不是写死 `主会话`：否则列表里的名字和会话存档对不上，
+                    // 用户也没法从列表确认改名是否生效。`[主会话]` 前缀由 CLI 渲染。
+                    name: active?.name || '主会话',
+                    label: null,
+                    topicStatus: 'pending',
+                    createdAt: lastTs,
+                    lastActiveAt: lastTs,
+                    mainSession: true,
+                    internal: false,
+                    msgTotal: 0,
+                    msg24h: 0,
+                    lastMsgSnippet: '',
+                };
+                // 该对端没有任何主会话往来时不造空行；状态/标签过滤对主会话也无意义，
+                // 只在未过滤时加入。
+                if (lastTs > 0 && !status && !label && !unlabeled)
+                    threads = [synthetic, ...threads];
+            }
+        }
         // 先读消息日志并派生真实活跃时间，再排序、再分页——
         // 否则 recent 排序用的是索引里的管理动作时间，与实际展示的活跃时间不一致。
         const ts24h = Date.now() - 86400000;
@@ -315,7 +509,7 @@ export class ThreadService {
                                 ? (payload.text ?? payload.content ?? '')
                                 : (m.content ?? '');
                             msgs.push({
-                                threadId: m.threadId ?? null,
+                                threadId: m.threadId ?? '',
                                 ts: m.ts ?? 0,
                                 snippet: String(text).replace(/\n/g, ' ').slice(0, 50),
                             });
@@ -332,10 +526,12 @@ export class ThreadService {
         const lastMsgOf = new Map();
         for (const t of threads) {
             const msgs = (peerMessages.get(`${entryChannelType(t)}\u0000${t.peer}`) ?? [])
-                .filter(m => m.threadId === t.threadId);
+                .filter(m => (m.threadId ?? '') === (t.threadId ?? ''));
             const lastMsg = msgs.reduce((acc, m) => (!acc || m.ts > acc.ts) ? m : acc, null);
+            // 合成的主会话条目用 `main` 作 threadId，日志里主会话记的是 null。
+            const key = t.threadId ?? '';
             if (lastMsg)
-                lastMsgOf.set(t.threadId, lastMsg);
+                lastMsgOf.set(key, lastMsg);
         }
         if (sort === 'created') {
             threads.sort((a, b) => b.createdAt - a.createdAt);
@@ -349,10 +545,10 @@ export class ThreadService {
         threads = threads.slice(offset, offset + limit);
         threads = threads.map(t => {
             const msgs = (peerMessages.get(`${entryChannelType(t)}\u0000${t.peer}`) ?? [])
-                .filter(m => m.threadId === t.threadId);
+                .filter(m => (m.threadId ?? '') === (t.threadId ?? ''));
             const msgTotal = msgs.length;
             const msg24h = msgs.filter(m => m.ts >= ts24h).length;
-            const lastMsg = lastMsgOf.get(t.threadId);
+            const lastMsg = lastMsgOf.get(t.threadId ?? '');
             const lastActiveAt = lastMsg?.ts || t.lastActiveAt;
             // 读该话题的 summary（当前最新版本）
             const summaryEntry = this.showSummary(selfAid, t.sessionId);
@@ -409,11 +605,11 @@ export class ThreadService {
             return { peer, messages: [] };
         const messages = readAllJsonlLines(logPath)
             .filter((m) => {
-            // threadId 为 undefined/null 时读主会话消息（threadId === null 的行），
-            // 否则按 threadId 精确匹配子话题消息。
+            // 不传 threadId 时读主会话消息：主会话的行 threadId 为 ''（历史残留 null
+            // 也按主会话处理），否则按 threadId 精确匹配子话题消息。
             if (threadId)
                 return m.threadId === threadId;
-            return m.threadId == null;
+            return !m.threadId;
         })
             .map((m) => {
             // 消息体优先取 payloadSummary.text（加密消息的明文摘要），
@@ -631,33 +827,26 @@ export class ThreadService {
     /**
      * 把话题的当前元数据追加一行到 _threads/<sessionId>.jsonl，
      * 使 rebuildIndex 读最后一行时能拿到 rename/label/status 后的最新值。
-     * 追加的行包含 fileToSession 所需的所有字段（从第一行继承），
+     * 追加的行以最后一行（当前权威快照）为底，只覆盖话题字段，
      * 确保 readMetaLatest 读最后一行时不报 "baseagent is empty"。
+     *
+     * 不能从第一行继承：第一行是创建记录，agentSessionId 为 null、没有 turnState，
+     * 继承它会把已绑定的后端会话冲掉；而且 meta 文件超限压缩后第一行也不再是创建记录。
      */
     appendThreadSnapshot(selfAid, entry) {
         const chatDir = this.chatDirFor(selfAid, entry.peer, entry.channelType);
         const metaPath = path.join(chatDir, '_threads', `${entry.sessionId}.jsonl`);
         if (!fs.existsSync(metaPath))
             return;
-        // Read the first line to inherit required session fields (id, baseagent, channel, etc.)
-        // so that fileToSession never sees a line missing mandatory fields.
-        const allLines = readAllJsonlLines(metaPath);
-        const firstLine = allLines[0] ?? {};
+        const latest = readLastJsonlLine(metaPath) ?? {};
         const now = entry.lastActiveAt;
-        appendJsonl(metaPath, {
-            // required session fields — inherited from the original creation record
-            id: firstLine.id ?? entry.sessionId,
-            channel: firstLine.channel,
-            channelType: firstLine.channelType,
-            channelId: firstLine.channelId,
-            sessionKey: firstLine.sessionKey,
-            selfAID: firstLine.selfAID,
-            baseagent: firstLine.baseagent,
-            projectPath: firstLine.projectPath ?? '',
-            agentSessionId: firstLine.agentSessionId,
+        appendJsonlDurable(metaPath, {
+            // session fields (id, baseagent, agentSessionId, metadata, activeTask...) — from the latest snapshot
+            ...latest,
+            id: latest.id ?? entry.sessionId,
+            projectPath: latest.projectPath ?? '',
             chatType: entry.peerKind === 'group' ? 'group' : 'private',
-            metadata: firstLine.metadata ?? {},
-            activeTask: null,
+            metadata: latest.metadata ?? {},
             // topic metadata — updated values
             threadId: entry.threadId,
             channelIdAlias: entry.peer,
@@ -665,7 +854,7 @@ export class ThreadService {
             label: entry.label,
             topicStatus: entry.topicStatus,
             createdAt: entry.createdAt,
-            createdAtStr: firstLine.createdAtStr ?? '',
+            createdAtStr: latest.createdAtStr ?? '',
             updatedAt: now,
             updatedAtStr: new Date(now).toISOString(),
         });
@@ -702,16 +891,16 @@ export class ThreadService {
      * 作为"这条摘要覆盖到哪"的游标。下次总结时用它作 `history --after` 起点，
      * 只读增量。话题为空（或主会话无消息）时不记录该字段。
      */
-    setSummary(selfAid, sessionId, content, ifRev) {
+    async setSummary(selfAid, sessionId, content, ifRev) {
         const dir = agentThreadSummariesDir(selfAid);
         fs.mkdirSync(dir, { recursive: true });
         const filePath = agentThreadSummaryPath(selfAid, sessionId);
-        const existing = this._readSummaryLines(filePath);
+        const coveredThroughTs = await this.resolveCoveredThroughTs(selfAid, sessionId);
+        const existing = this._readAllSummaryLines(filePath);
         const currentRev = existing.length;
         if (ifRev !== undefined && ifRev !== currentRev) {
             throw new ThreadServiceError(`summary CAS 冲突：期望版本 ${ifRev}，当前版本 ${currentRev}`, 'SUMMARY_CAS_CONFLICT');
         }
-        const coveredThroughTs = this.resolveCoveredThroughTs(selfAid, sessionId);
         const entry = {
             rev: currentRev + 1,
             content,
@@ -726,12 +915,25 @@ export class ThreadService {
      *
      * 话题内总结时这就是"当前消息"，跨话题总结时（先读全增量再写）也是同一语义。
      * 话题不存在或无消息时返回 undefined——此时摘要没有游标，下次总结只能全量读。
+     *
+     * 主会话不进话题索引（它由会话文件产生），索引里查不到时按 sessionId 回退到
+     * session 本身：peer 取 channelId，threadId 取 session.threadId（主会话为空串）。
+     * 不回退的话主会话摘要永远没有游标，增量总结在主会话上不成立。
      */
-    resolveCoveredThroughTs(selfAid, sessionId) {
+    async resolveCoveredThroughTs(selfAid, sessionId) {
         const entry = this.readThreadIndex(selfAid).threads.find(t => t.sessionId === sessionId);
-        if (!entry)
+        let peer = entry?.peer;
+        let threadId = entry?.threadId;
+        if (!entry) {
+            const session = await this.sessionManager.getSessionById(sessionId);
+            if (!session)
+                return undefined;
+            peer = session.channelId;
+            threadId = session.threadId ?? '';
+        }
+        if (!peer)
             return undefined;
-        const { messages } = this._readThreadMessages(selfAid, entry.peer, entry.threadId);
+        const { messages } = this._readThreadMessages(selfAid, peer, threadId);
         if (messages.length === 0)
             return undefined;
         return messages[messages.length - 1].timestamp;
@@ -760,18 +962,23 @@ export class ThreadService {
      */
     clearSummary(selfAid, sessionId) {
         const filePath = agentThreadSummaryPath(selfAid, sessionId);
-        const existing = this._readSummaryLines(filePath);
+        // 计数必须含墓碑：rev 是文件行序号，过滤后会与已有墓碑撞号。
+        const existing = this._readAllSummaryLines(filePath);
         if (existing.length === 0)
             return; // 已无内容，幂等
         const dir = agentThreadSummariesDir(selfAid);
         fs.mkdirSync(dir, { recursive: true });
         appendJsonl(filePath, { rev: existing.length + 1, content: null, updatedAt: Date.now() });
     }
-    _readSummaryLines(filePath) {
+    /** 全部记录，含 clear 墓碑（content=null）。rev/CAS 计数一律基于这个。 */
+    _readAllSummaryLines(filePath) {
         if (!fs.existsSync(filePath))
             return [];
-        const all = readAllJsonlLines(filePath);
-        // 过滤掉 clear 墓碑（content=null），只返回实际写入的版本
-        return all.filter(l => l.content !== null);
+        return readAllJsonlLines(filePath);
+    }
+    /** 只含实际写入的版本，不含 clear 墓碑。仅用于展示历史。 */
+    _readSummaryLines(filePath) {
+        return this._readAllSummaryLines(filePath)
+            .filter(l => l.content !== null);
     }
 }

package/dist/eck/kit-renderer.js

@@ -6,6 +6,7 @@ import { logger } from '../utils/logger.js';
 import { clearRoleStoreCache } from '../config/role-store.js';
 import { resolveAgentLifecycle } from '../config/lifecycle.js';
 import { loadManifest, loadManifestMeta, invalidateManifestCache, evaluateWhen, renderTemplate, renderLoopSection, resolvePathWithDiag, loadSectionFiles, loadChildTemplate, buildPathMappings, shortenPath, } from './manifest-engine.js';
+import { SYSTEM_SESSION_TYPES } from '../core/system-session/types.js';
 export const DEFAULT_MANIFEST_FILE = 'eck_manifest.json';
 /**
  * 会话原型（sessionType）→ manifest 文件的内置映射。
@@ -16,9 +17,13 @@ export const BUILTIN_SESSION_MANIFESTS = {
     memory: 'eck_manifest.memory.json',
     auxiliary: 'eck_manifest.auxiliary.json',
 };
-/** 选择顺序：config 覆盖 → 内置映射 → 主 manifest。 */
+/**
+ * 选择顺序：config 覆盖 → 内置映射 → 主 manifest。
+ * 系统会话类型不接受 config 覆盖：其 manifest 由 system-session 模块决定。
+ */
 export function resolveSessionManifest(sessionType, overrides) {
-    return overrides?.[sessionType] ?? BUILTIN_SESSION_MANIFESTS[sessionType] ?? DEFAULT_MANIFEST_FILE;
+    const override = SYSTEM_SESSION_TYPES.includes(sessionType) ? undefined : overrides?.[sessionType];
+    return override ?? BUILTIN_SESSION_MANIFESTS[sessionType] ?? DEFAULT_MANIFEST_FILE;
 }
 // ── Caches ──
 const _sessionPathCache = new Map();

package/dist/eck/manifest-engine.js

@@ -3,9 +3,10 @@
 // when 求值、模板渲染、路径解析、manifest 加载/缓存原语，避免两套实现漂移。
 import fs from 'fs';
 import path from 'path';
-import { kitsDir, resolveRoot, getPackageRoot } from '../paths.js';
+import { kitsDir, resolveRoot, getPackageRoot, isDevMode } from '../paths.js';
 import { logger } from '../utils/logger.js';
 import { fileCache } from '../core/daemon-file-cache.js';
+import { readVerifiedText, isShippedPath } from '../core/file-integrity/read.js';
 // ── 限额默认值 ──
 /** 单目录段默认最多文件数 */
 export const DIR_MAX_FILES = 20;
@@ -365,12 +366,31 @@ function sectionCacheOptions(resolvedPath, vars) {
     }
     return { policy: 'mtime', group: 'eck-runtime' };
 }
+/**
+ * 读取一个 kits 文档，安装模式下先过台账校验。
+ *
+ * 为什么校验包在 loader 里：这些内容走 FileCache 的 `on-reload` 策略，缓存命中时
+ * 不会碰磁盘，校验只有包在这里才与"实际注入的那份内容"对齐；被篡改且恢复不了时
+ * 返回 null，条目本身也不会写进缓存。开发模式下 kits 由 agent 直接改写，不校验。
+ */
+function loadKitsDoc(resolved, vars) {
+    const opts = sectionCacheOptions(resolved, vars);
+    if (!isShippedPath(resolved)) {
+        return fileCache.getText(resolved, opts);
+    }
+    const verify = !isDevMode();
+    return fileCache.get(resolved, () => {
+        const checked = readVerifiedText(resolved, { verify, tag: 'eck' });
+        // 校验不过就不进缓存：返回 null → fileCache 存 null，该段被丢弃
+        return checked ? checked.text : null;
+    }, opts);
+}
 /** 加载 loop 的 child 子模板文件内容（路径解析 + fileCache）。找不到返回 null。 */
 export function loadChildTemplate(childFile, vars) {
     const resolved = resolvePath(childFile, vars);
     if (!resolved)
         return null;
-    return fileCache.getText(resolved, sectionCacheOptions(resolved, vars));
+    return loadKitsDoc(resolved, vars);
 }
 /**
  * 返回 [filePath, rawContent][]。kits 文件跨 session 缓存到 reload；运行时文件
@@ -401,7 +421,7 @@ function loadFileSection(filePath, vars, sessionCache) {
     const resolved = resolvePath(filePath, vars);
     if (!resolved)
         return null;
-    const content = fileCache.getText(resolved, sectionCacheOptions(resolved, vars));
+    const content = loadKitsDoc(resolved, vars);
     return content === null ? null : [resolved, content];
 }
 /**
@@ -435,7 +455,7 @@ function readDirectoryFiles(dirPath, pattern, maxFiles, maxBytes, vars) {
             break;
         }
         const fp = path.join(dirPath, f);
-        const content = fileCache.getText(fp, sectionCacheOptions(fp, vars));
+        const content = loadKitsDoc(fp, vars);
         if (content === null)
             continue;
         // 字节限额（至少加载一个文件，避免单个超大文件导致空目录）

package/dist/index.js

@@ -1,7 +1,7 @@
 // 【重要】最先加载环境变量，确保后续模块初始化时可用
 import dotenv from 'dotenv';
 import path from 'path';
-import { ensureDataDirs, resolvePaths, eckDebugDir, daemonControlDir, daemonQueuePath, daemonMessageDedupPath } from './paths.js';
+import { ensureDataDirs, resolvePaths, eckDebugDir, daemonControlDir, daemonQueuePath, daemonMessageDedupPath, isDevMode } from './paths.js';
 // 立即加载 .env 文件（在其他模块导入之前）
 try {
     dotenv.config({ path: path.join(resolvePaths().root, '.env') });
@@ -57,6 +57,7 @@ import { StatsCollector } from './utils/stats.js';
 import { AidStatsCollector } from './utils/stats.js';
 import { initializeStatsPersistence } from './stats/writer.js';
 import { PermissionGateway } from './core/permission/approval-gateway.js';
+import { releaseSessionPathGrants } from './core/permission/session-path-grants.js';
 import { InteractionRouter } from './core/interaction-router.js';
 import { GroupInviteReviewService } from './aun/group/invite-service.js';
 import { AgentDelegationRegistry, } from './core/auth/agent-delegation.js';
@@ -138,8 +139,10 @@ async function main() {
     }
     // 立即登记自己（让其他并发启动者能看见我）
     const launchedBy = process.env.EVOLCORE_LAUNCHED_BY || 'start';
+    // 本次运行模式在这里定下（首次求值时会读走并删除 `ec start --as-mode` 的覆盖文件）
+    const devMode = isDevMode();
     writeMain(launchedBy);
-    logger.info(`✓ Instance record written: main-${process.pid}.json`);
+    logger.info(`✓ Instance record written: main-${process.pid}.json runMode=${devMode ? 'dev' : 'install'}`);
     // post-write 自检：写完 record 后再扫一次，发现并发对手时按 (startedAt, pid) 选赢家
     {
         const verdict = isMainWinner();
@@ -240,6 +243,12 @@ async function main() {
         if (event.nameChanged)
             agentRegistry?.invalidateAgentDisplayCache?.(event.aid);
     });
+    // 运行时路径授权以会话为归属：会话被删除后不再有身份去消费它，随之释放。
+    // 只挂 session:deleted——session:idle 只表示空闲，会话仍会继续服务。
+    eventBus.subscribe('session:deleted', (event) => {
+        if ('sessionId' in event && event.sessionId)
+            releaseSessionPathGrants(event.sessionId);
+    });
     // 统计收集器（近 1 小时滚动统计）
     const statsCollector = new StatsCollector(eventBus);
     // Per-AID 消息统计收集器（累计，供 watch aid 实时展示）