evolcore 0.0.35 → 0.0.37

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

@@ -5,6 +5,8 @@ import { agentSessionsDir, agentDir, agentThreadIndexPath, agentThreadSummariesD
 import { atomicWriteJson, atomicReadJson } from '../../utils/atomic-write.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 { isMainSessionThreadId, isTopicThreadId, mainTopicPeer, safeFormatMainTopicId, sessionTopicThreadId } from './topic-id.js';
+import { PeerIdentityCache } from '../relation/peer-identity.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']);
@@ -144,7 +146,79 @@ export class ThreadService {
     findInIndex(selfAid, peer, threadId) {
         const want = normalizeThreadPeer(peer);
         const index = this.readThreadIndex(selfAid);
-        return index.threads.find(t => normalizeThreadPeer(t.peer) === want && t.threadId === threadId);
+        const indexed = index.threads.find(t => normalizeThreadPeer(t.peer) === want && t.threadId === threadId);
+        if (indexed)
+            return indexed;
+        // Older agents can still have a valid topic session under the per-chat
+        // `_threads/` directory while the consolidated agent index only contains
+        // newer topics. Summary reads depend on the consolidated index, so repair
+        // the missing entry lazily when a concrete topic is requested.
+        const recovered = this.recoverThreadFromSessionFiles(selfAid, want, threadId);
+        if (!recovered)
+            return undefined;
+        const next = {
+            version: 1,
+            threads: [...index.threads, recovered],
+        };
+        try {
+            this.writeThreadIndex(selfAid, next);
+        }
+        catch {
+            // An unwritable derived index must not hide a readable topic. Retry the
+            // repair on its next lookup, as with the legacy index-path migration.
+        }
+        return recovered;
+    }
+    recoverThreadFromSessionFiles(selfAid, peer, threadId) {
+        if (!peer || !threadId || RESERVED_THREAD_IDS.has(threadId))
+            return undefined;
+        const sessionsDir = agentSessionsDir(selfAid);
+        if (!fs.existsSync(sessionsDir))
+            return undefined;
+        for (const dirEntry of fs.readdirSync(sessionsDir, { withFileTypes: true })) {
+            if (!dirEntry.isDirectory())
+                continue;
+            const parsedDir = tryParseChannelSessionKey(dirEntry.name);
+            if (!parsedDir || normalizeThreadPeer(parsedDir.channelId) !== peer)
+                continue;
+            const chatDir = path.join(sessionsDir, dirEntry.name);
+            const threadsDir = path.join(chatDir, '_threads');
+            if (!fs.existsSync(threadsDir))
+                continue;
+            for (const file of fs.readdirSync(threadsDir, { withFileTypes: true })) {
+                if (!file.isFile() || !file.name.endsWith('.jsonl'))
+                    continue;
+                const sessionId = file.name.slice(0, -'.jsonl'.length);
+                try {
+                    const last = readLastJsonlLine(path.join(threadsDir, file.name));
+                    if (!last || last.threadId !== threadId)
+                        continue;
+                    if (normalizeThreadPeer(last.channelId) !== peer)
+                        continue;
+                    if (last.selfAID && last.selfAID !== selfAid)
+                        continue;
+                    if (last.id && last.id !== sessionId)
+                        continue;
+                    return {
+                        threadId,
+                        sessionId,
+                        peer,
+                        channelType: parsedDir.channelType,
+                        peerKind: last.chatType === 'group' ? 'group' : 'private',
+                        name: last.name ?? threadId,
+                        label: last.label ?? null,
+                        topicStatus: last.topicStatus ?? 'pending',
+                        createdAt: last.createdAt ?? 0,
+                        lastActiveAt: last.updatedAt ?? 0,
+                        ...(last.nameUpdatedAt !== undefined ? { nameUpdatedAt: last.nameUpdatedAt } : {}),
+                    };
+                }
+                catch {
+                    // Ignore an unrelated or corrupt historical session file.
+                }
+            }
+        }
+        return undefined;
     }
     /**
      * 该条目对应的会话目录。
@@ -221,19 +295,25 @@ export class ThreadService {
         if (!sanitized)
             throw new ThreadServiceError('话题名称不能为空', 'INVALID_NAME');
         assertThreadNameLength(name, sanitized);
-        // 主会话（threadId 为空）从不进话题索引，它由会话文件产生。
+        // 主话题（threadId 为空 / `main` / 规范 id）从不进话题索引，它由会话文件产生。
         // 改名直接落到 active session 上，不走索引与快照。
         // 群里主会话名只有 admin/owner 能改，且在授权层已经拦过；这里照常落本地。
-        if (!threadId) {
+        if (isMainSessionThreadId(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 nameUpdatedAt = Math.max(Date.now(), Number(main.nameUpdatedAt ?? 0) + 1);
+            // sessionId 为空说明目录存在但 active.json 还没生成（旧数据从未经过 daemon 持久化）。
+            // 此时本地存储里没有 session 记录可以改，跳过 renameSession 直接返回成功——
+            // 改名通知会发出去，对端能看到；本端下次 daemon 首次处理该会话时会写 active.json。
+            if (main.sessionId) {
+                const renamed = await this.sessionManager.renameSession(main.sessionId, sanitized, nameUpdatedAt);
+                if (!renamed)
+                    throw new ThreadServiceError(`主会话改名失败: ${main.sessionId}`, 'RENAME_FAILED');
+            }
+            return { changed: true, name: sanitized, nameUpdatedAt, peerKind: main.peerKind };
         }
         const index = this.readThreadIndex(selfAid);
         const entry = index.threads.find(t => t.peer === peer && t.threadId === threadId);
@@ -252,10 +332,10 @@ export class ThreadService {
         if (session) {
             await this.sessionManager.renameSession(session.id, sanitized);
         }
-        return { changed: true, name: sanitized, nameUpdatedAt };
+        return { changed: true, name: sanitized, nameUpdatedAt, peerKind: entry.peerKind };
     }
     /**
-     * 应用对端发来的改名通知（`topic-renamed`）。
+     * 应用对端发来的改名通知（`event/topic.renamed`）。
      *
      * 判据是最新更新时间先到先赢：通知里的 `nameUpdatedAt` 只有**严格大于**本地
      * 记录时才生效。对端尚未建档时按通知内容建条目（与会话自动建档一致），
@@ -263,9 +343,25 @@ export class ThreadService {
      */
     async applyRemoteRename(input) {
         const sanitized = sanitizeSessionTitle(input.name);
-        if (!sanitized || !input.threadId)
+        if (!sanitized || !isMainSessionThreadId(input.threadId) && !isTopicThreadId(input.threadId)) {
             return { applied: false, reason: 'invalid' };
+        }
         const peer = normalizeThreadPeer(input.peer) ?? input.peer;
+        // 主话题：与话题同一套改名语义，只是落到主会话上——主话题从不进话题索引，
+        // 这里绝不能新建条目（会凭空多出一条不存在的话题）。id 自带双方，
+        // 先校验另一端就是本次发送方，避免拿别人的主话题 id 改错关系。
+        if (isMainSessionThreadId(input.threadId)) {
+            if (mainTopicPeer(input.threadId, input.selfAid) !== peer) {
+                return { applied: false, reason: 'invalid' };
+            }
+            const main = await this.showMainSession(input.selfAid, peer);
+            if (!main)
+                return { applied: false, reason: 'invalid' };
+            if (input.nameUpdatedAt <= Number(main.nameUpdatedAt ?? 0))
+                return { applied: false, reason: 'stale' };
+            const renamed = await this.sessionManager.renameSession(main.sessionId, sanitized, input.nameUpdatedAt);
+            return renamed ? { applied: true } : { applied: false, reason: 'invalid' };
+        }
         const index = this.readThreadIndex(input.selfAid);
         const entry = index.threads.find(t => t.peer === peer && t.threadId === input.threadId);
         const current = entry?.nameUpdatedAt ?? 0;
@@ -367,7 +463,7 @@ export class ThreadService {
             }
         }
         // 索引之外的兜底：磁盘上真实存在、且有消息或会话存档的 chat 目录。
-        // 只加索引里没有的对端——索引已经有了的，子话题数已算过，不再重复计主会话。
+        // 只加索引里没有的对端——索引已经有了的，话题数已算过，不再重复计主会话。
         // 从目录名解析 peer 与 channelType，避免信赖可能过期的索引字段。
         try {
             const agentsRoot = path.dirname(agentDir(selfAid));
@@ -420,7 +516,9 @@ export class ThreadService {
             catch {
                 // 消息日志缺失/损坏时保持索引值
             }
-            return { peer, peerKind: v.peerKind, threadCount: v.threadCount, lastActiveAt };
+            const cached = PeerIdentityCache.get('aun', peer, agentDir(selfAid));
+            const peerName = cached?.name ?? (typeof cached?.metadata?.['name'] === 'string' ? cached.metadata['name'] : undefined);
+            return { peer, peerName, peerKind: v.peerKind, threadCount: v.threadCount, lastActiveAt };
         })
             .sort((a, b) => b.lastActiveAt - a.lastActiveAt);
     }
@@ -441,12 +539,11 @@ export class ThreadService {
                 return false;
             return true;
         });
-        // 主会话是 threadId 为 `''` 的话题：它由会话文件而非 createThread 产生，
-        // 所以从不进话题索引。只列子话题会让「和某对端聊过什么」在列表里看不到主线，
-        // 而 `history <peer>` 不传 threadId 读的恰恰是主会话消息。指定对端时补一条
-        // 合成记录，让 list 与 history 的口径一致。
+        // 主话题由会话文件产生、从不进话题索引。只列话题会让「和某对端聊过什么」
+        // 在列表里看不到主线，而 `history <peer>` 不传话题读的恰恰是主话题消息。
+        // 指定对端时补一条合成记录，让 list 与 history 的口径一致。
         if (peer) {
-            const hasMain = threads.some(t => !t.threadId);
+            const hasMain = threads.some(t => isMainSessionThreadId(t.threadId));
             if (!hasMain) {
                 const chatDir = this.chatDirFor(selfAid, peer);
                 const logPath = path.join(chatDir, 'messages.jsonl');
@@ -454,7 +551,7 @@ export class ThreadService {
                 if (fs.existsSync(logPath)) {
                     try {
                         for (const m of readAllJsonlLines(logPath)) {
-                            if (!m.threadId && typeof m.ts === 'number' && m.ts > lastTs)
+                            if (isMainSessionThreadId(m.threadId) && typeof m.ts === 'number' && m.ts > lastTs)
                                 lastTs = m.ts;
                         }
                     }
@@ -465,14 +562,15 @@ export class ThreadService {
                 const active = this.sessionManager.getActiveSessionSync('aun', peer, 'aun', selfAid);
                 const peerKind = active?.chatType === 'group' ? 'group' : 'private';
                 const synthetic = {
-                    threadId: '',
+                    // 主话题的 id 与话题并列，同样可直接作为 --thread 的值。
+                    threadId: safeFormatMainTopicId(selfAid, peer) ?? '',
                     sessionId: active?.id ?? '',
                     peer,
                     channelType: 'aun',
                     peerKind,
                     // 主会话有自己的名字（创建时写 `默认会话`，可经 ec thread rename 修改）。
                     // 读真实值而不是写死 `主会话`：否则列表里的名字和会话存档对不上，
-                    // 用户也没法从列表确认改名是否生效。`[主会话]` 前缀由 CLI 渲染。
+                    // 用户也没法从列表确认改名是否生效。`[主话题]` 前缀由 CLI 渲染。
                     name: active?.name || '主会话',
                     label: null,
                     topicStatus: 'pending',
@@ -493,6 +591,10 @@ export class ThreadService {
         // 先读消息日志并派生真实活跃时间，再排序、再分页——
         // 否则 recent 排序用的是索引里的管理动作时间，与实际展示的活跃时间不一致。
         const ts24h = Date.now() - 86400000;
+        // 主话题在消息日志里可能是历史空值/`main`，也可能是现行规范 id；两者都算同一条主线。
+        const msgBelongsTo = (msgThreadId, topicThreadId) => isMainSessionThreadId(topicThreadId)
+            ? isMainSessionThreadId(msgThreadId)
+            : (msgThreadId ?? '') === (topicThreadId ?? '');
         // 按会话目录分组，每个目录只读一次 messages.jsonl。
         // 键用 channelType + peer，避免不同命名空间下同名对端串数据。
         const peerMessages = new Map();
@@ -526,12 +628,10 @@ 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 => msgBelongsTo(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(key, lastMsg);
+                lastMsgOf.set(t.threadId ?? '', lastMsg);
         }
         if (sort === 'created') {
             threads.sort((a, b) => b.createdAt - a.createdAt);
@@ -545,7 +645,7 @@ 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 => msgBelongsTo(m.threadId, t.threadId));
             const msgTotal = msgs.length;
             const msg24h = msgs.filter(m => m.ts >= ts24h).length;
             const lastMsg = lastMsgOf.get(t.threadId ?? '');
@@ -598,18 +698,20 @@ export class ThreadService {
         const peer = normalizeThreadPeer(peerInput) ?? peerInput;
         // 不检查索引——允许读取已删除话题的历史（session 文件已移入 _trash，但 messages.jsonl 仍在）
         // 索引里能查到条目时用条目的命名空间（内部话题在 daemon 下），查不到时退回 aun。
-        const indexed = this.readThreadIndex(selfAid).threads.find(t => t.threadId === threadId && normalizeThreadPeer(t.peer) === peer);
+        const indexed = isMainSessionThreadId(threadId)
+            ? undefined
+            : this.readThreadIndex(selfAid).threads.find(t => t.threadId === threadId && normalizeThreadPeer(t.peer) === peer);
         const chatDir = this.chatDirFor(selfAid, indexed?.peer ?? peer, indexed?.channelType);
         const logPath = path.join(chatDir, 'messages.jsonl');
         if (!fs.existsSync(logPath))
             return { peer, messages: [] };
         const messages = readAllJsonlLines(logPath)
             .filter((m) => {
-            // 不传 threadId 时读主会话消息：主会话的行 threadId 为 ''（历史残留 null
-            // 也按主会话处理），否则按 threadId 精确匹配子话题消息。
-            if (threadId)
-                return m.threadId === threadId;
-            return !m.threadId;
+            // 主话题的消息行在历史里是 '' 或 null，新写入的是规范 id；三种都算主话题。
+            // 话题按 id 精确匹配。
+            if (isMainSessionThreadId(threadId))
+                return isMainSessionThreadId(m.threadId);
+            return m.threadId === threadId;
         })
             .map((m) => {
             // 消息体优先取 payloadSummary.text（加密消息的明文摘要），
@@ -651,7 +753,10 @@ export class ThreadService {
             count: Math.min(filtered.length, limit),
             total: filtered.length,
             messages: shown,
-            threadId: threadId ?? '',
+            // 主话题返回规范 id，让调用方拿到的东西可以直接再当 `--thread` 用。
+            threadId: isMainSessionThreadId(threadId)
+                ? (safeFormatMainTopicId(selfAid, peer) ?? '')
+                : (threadId ?? ''),
             peer,
         };
     }
@@ -748,20 +853,42 @@ export class ThreadService {
         const normalized = normalizeThreadPeer(peer) ?? peer;
         const channelKey = `aun#${selfAid}#main`;
         const session = await this.sessionManager.getActiveSession(channelKey, normalized);
-        if (!session)
+        if (session) {
+            return {
+                // 主话题返回规范 id（按调用方给的 selfAid/peer 拼），话题返回话题 id。
+                threadId: sessionTopicThreadId(session)
+                    ?? (safeFormatMainTopicId(selfAid, normalized) ?? ''),
+                sessionId: session.id,
+                peer: normalized,
+                channelType: 'aun',
+                peerKind: session.chatType === 'group' ? 'group' : 'private',
+                name: session.name ?? peer,
+                nameUpdatedAt: typeof session.metadata?.nameUpdatedAt === 'number' ? session.metadata.nameUpdatedAt : undefined,
+                label: session.label ?? null,
+                topicStatus: session.topicStatus ?? 'pending',
+                createdAt: session.createdAt ?? 0,
+                lastActiveAt: session.updatedAt ?? 0,
+                running: session.processingState?.startsWith('processing') ?? false,
+            };
+        }
+        // active.json 不存在时（旧数据，未经 daemon 持久化），回退到目录推断。
+        // findMainSessionEntry 用目录存在性 + messages.jsonl 第一行推断 chatType。
+        const entry = ThreadService.findMainSessionEntry(selfAid, normalized);
+        if (!entry)
             return undefined;
         return {
-            threadId: session.threadId ?? '',
-            sessionId: session.id,
+            threadId: entry.threadId,
+            sessionId: entry.sessionId,
             peer: normalized,
             channelType: 'aun',
-            peerKind: session.chatType === 'group' ? 'group' : 'private',
-            name: session.name ?? peer,
-            label: session.label ?? null,
-            topicStatus: session.topicStatus ?? 'pending',
-            createdAt: session.createdAt ?? 0,
-            lastActiveAt: session.updatedAt ?? 0,
-            running: session.processingState?.startsWith('processing') ?? false,
+            peerKind: entry.peerKind,
+            name: entry.name,
+            nameUpdatedAt: undefined,
+            label: null,
+            topicStatus: 'pending',
+            createdAt: entry.createdAt,
+            lastActiveAt: entry.lastActiveAt,
+            running: false,
         };
     }
     // ── touch (update lastActiveAt) ──
@@ -783,7 +910,7 @@ export class ThreadService {
      * 禁止删除：busy（processingState 有值）的话题，以及 threadId 为空的主会话。
      */
     async deleteThread(selfAid, peer, threadId) {
-        if (!threadId)
+        if (isMainSessionThreadId(threadId))
             throw new ThreadServiceError('不能删除主会话', 'NOT_A_TOPIC');
         const want = normalizeThreadPeer(peer);
         const indexPath = agentThreadIndexPath(selfAid);
@@ -865,7 +992,71 @@ export class ThreadService {
         const index = readIndex(agentThreadIndexPath(selfAid));
         return index.threads.find(t => t.threadId === threadId);
     }
-    // ── Thread Context inbox（跨会话上下文的提醒缓存） ──
+    /**
+     * 同步读取主会话（threadId=null/空/"main"）的等价 ThreadIndexEntry。
+     * 主会话不写入 threads 索引，需直读 active.json 构造。
+     * 供 resolveThreadRouteTarget 跨话题路由校验时使用。
+     */
+    static findMainSessionEntry(selfAid, peer) {
+        const normalizedPeer = normalizeThreadPeer(peer) ?? peer;
+        const channelKey = `aun#${selfAid}#main`;
+        // chatDirPath 期望的是 `<root>/agents` 这一级，它会自己拼 `<aid>/sessions/...`；
+        // 传 agentSessionsDir 会得到 `agents/<aid>/sessions/<aid>/sessions/...` 的双层路径。
+        const agentsRoot = path.dirname(agentDir(selfAid));
+        const dir = chatDirPath(agentsRoot, 'aun', normalizedPeer, selfAid, channelKey);
+        // 先尝试 active.json（热缓存，有则最准确）。
+        let raw;
+        try {
+            raw = JSON.parse(fs.readFileSync(`${dir}/active.json`, 'utf8'));
+            // active.json 里 threadId 是话题 id 说明该目录放的不是主会话，丢弃。
+            if (isTopicThreadId(raw['threadId']))
+                return undefined;
+        }
+        catch {
+            raw = undefined;
+        }
+        // active.json 不存在（旧数据或未触发持久化）时，用目录本身推断：
+        // 目录存在说明主会话存在，从 messages.jsonl 第一行读 chatType 补齐 peerKind。
+        if (!raw) {
+            if (!fs.existsSync(dir))
+                return undefined;
+            let chatType;
+            try {
+                const firstLine = fs.readFileSync(`${dir}/messages.jsonl`, 'utf8').split('\n')[0];
+                if (firstLine?.trim()) {
+                    const msg = JSON.parse(firstLine);
+                    chatType = typeof msg['chatType'] === 'string' ? msg['chatType'] : undefined;
+                }
+            }
+            catch { /* 读取失败时留 undefined，下面用默认值 */ }
+            const peerKind = chatType === 'group' ? 'group' : 'private';
+            return {
+                threadId: safeFormatMainTopicId(selfAid, normalizedPeer) ?? '',
+                sessionId: '',
+                peer: normalizedPeer,
+                channelType: 'aun',
+                peerKind,
+                name: normalizedPeer,
+                topicStatus: 'pending',
+                createdAt: 0,
+                lastActiveAt: 0,
+            };
+        }
+        const chatType = raw['chatType'];
+        const peerKind = chatType === 'group' ? 'group' : 'private';
+        return {
+            threadId: safeFormatMainTopicId(selfAid, normalizedPeer) ?? '',
+            sessionId: String(raw['id'] ?? raw['agentSessionId'] ?? ''),
+            peer: normalizedPeer,
+            channelType: 'aun',
+            peerKind,
+            name: String(raw['name'] ?? normalizedPeer),
+            topicStatus: raw['topicStatus'] ?? 'pending',
+            createdAt: Number(raw['createdAt'] ?? 0),
+            lastActiveAt: Number(raw['updatedAt'] ?? 0),
+        };
+    }
+    // ── Thread Context inbox（跨话题上下文的提醒缓存） ──
     /** 跨话题发送成功后写入本端 inbox。 */
     static appendInbox(selfAid, entry) {
         new ThreadContextStorage().append(selfAid, entry);
@@ -929,7 +1120,7 @@ export class ThreadService {
             if (!session)
                 return undefined;
             peer = session.channelId;
-            threadId = session.threadId ?? '';
+            threadId = sessionTopicThreadId(session) ?? '';
         }
         if (!peer)
             return undefined;