evolcore 0.0.35 → 0.0.36

package/dist/core/thread/command-parser.js

@@ -1,5 +1,7 @@
 import { isValidAid } from '../../aun/aid/validation.js';
+import { parseTimeArg, TIME_ARG_FORMATS } from '../../cli/cli-argv.js';
 import { normalizeThreadPeer } from './thread-service.js';
+import { resolveThreadRef } from './topic-id.js';
 const STATUSES = new Set(['pending', 'in_progress', 'completed', 'archived']);
 const COMMON_OPTIONS = ['--self', '--format', '--json'];
 const VALUE_OPTIONS = new Set(['--self', '--agent', '--format', '--name', '--label', '--status', '--sort', '--page', '--limit', '--before', '--after', '--if-rev']);
@@ -45,6 +47,14 @@ export function resolveThreadCommandArgv(argv) {
             throw new Error(`Invalid number: ${flag}`);
         return value;
     };
+    const time = (flag) => {
+        if (!options.has(flag))
+            return undefined;
+        const value = parseTimeArg(text(flag));
+        if (value === undefined)
+            throw new Error(`Invalid time: ${flag}（支持 ${TIME_ARG_FORMATS}）`);
+        return value;
+    };
     const selfAidValue = text('--self');
     const agentAidValue = text('--agent');
     const selfAid = (agentAidValue ?? selfAidValue)?.replace(/^@/, '');
@@ -77,18 +87,23 @@ export function resolveThreadCommandArgv(argv) {
     else if (maximum !== 0) {
         request.ref = positional[0];
         if (request.ref !== 'current') {
-            const pieces = positional[0].split('/');
-            if (pieces.length > 2 || !pieces[0] || pieces[1] === '')
-                throw new Error('Invalid thread reference');
-            request.peer = normalizeThreadPeer(pieces[0]);
-            // 主会话的 threadId 是空串；`<peer>/main` 是同义写法（list 也这样显示）。
-            // `rename` 额外把裸 peer 也当成主会话：不写斜杠时改的是主会话名，
-            // 与 `list` / `history` 不传 threadId 读主会话的口径一致。
-            request.threadId = pieces[1] === 'main' || (command === 'rename' && pieces.length === 1)
-                ? ''
-                : pieces[1];
-            if (!request.peer || request.threadId && !/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(request.threadId))
-                throw new Error('Invalid thread reference');
+            // 与 CLI 共用同一套解析：主话题是 `main:<aid>:<aid>`，话题是裸 id，
+            // 历史写法 `<peer>/<id>` 仍接受。裸 `main` 与 `<peer>/main` 都被拒绝。
+            const selfForRef = selfAid ?? (process.env.EVOLCORE_SELF_AID?.replace(/^@/, '') || '');
+            const resolved = resolveThreadRef(request.ref, selfForRef);
+            if (resolved.kind === 'invalid')
+                throw new Error(resolved.error);
+            if (resolved.kind === 'thread') {
+                request.peer = resolved.peer ? normalizeThreadPeer(resolved.peer) : undefined;
+                request.threadId = resolved.threadId;
+            }
+            else if (resolved.kind === 'main') {
+                request.peer = normalizeThreadPeer(resolved.peer);
+                request.threadId = resolved.topicId;
+            }
+            // 裸对端 AID 已由 resolveThreadRef 解析成主话题（peer + 规范 id），
+            // 这里不能再按"裸值就是对端"覆盖，否则会把 `rename <peer>` 变成
+            // "改当前会话所在话题"，静默改错对象。
         }
     }
     if (command === 'list')
@@ -97,7 +112,7 @@ export function resolveThreadCommandArgv(argv) {
             page: number('--page', 1), limit: number('--limit', 1),
         });
     if (command === 'history')
-        Object.assign(request, { limit: number('--limit', 1), before: number('--before'), after: number('--after') });
+        Object.assign(request, { limit: number('--limit', 1), before: time('--before'), after: time('--after') });
     if (command === 'create') {
         if (!text('--name')?.trim())
             throw new Error('Topic name is required');

package/dist/core/thread/index.js

@@ -1 +1,2 @@
 export { ThreadService, ThreadServiceError, normalizeThreadPeer } from './thread-service.js';
+export { MAIN_TOPIC_PREFIX, normalizeTopicAid, formatMainTopicId, safeFormatMainTopicId, isMainTopicId, parseMainTopicId, mainTopicPeer, canonicalizeMainTopicId, isMainSessionThreadId, isTopicThreadId, resolveThreadRef, } from './topic-id.js';

package/dist/core/thread/ipc-operation.js

@@ -1,7 +1,8 @@
 import { trustedExecutionIdentityInput } from '../auth/agent-delegation.js';
-import { authorizeOperation, buildAuthSubject } from '../auth/auth-gateway.js';
+import { authorizeFreshOperation as authorizeOperation, buildAuthSubject } from '../auth/auth-gateway.js';
 import { parsePeerKey } from '../relation/peer-identity.js';
 import { resolveThreadCommandArgv } from './command-parser.js';
+import { isTopicThreadId, sessionTopicThreadId } from './topic-id.js';
 import { executeThreadOperation } from './thread-operation.js';
 import { ThreadService } from './thread-service.js';
 export function createThreadOperationExecutor(dependencies) {
@@ -12,9 +13,10 @@ export function createThreadOperationExecutor(dependencies) {
                 return { ok: false, code: 'INVALID_REQUEST', error: 'Thread operations require argv' };
             const request = resolveThreadCommandArgv(incoming.argv);
             const token = typeof incoming.delegationToken === 'string' ? incoming.delegationToken.trim() : '';
-            // `request` 是从 argv 重建的，不含调用方凭据。后续系统通知（topic-renamed
-            // 等）要经 `sendAunMsg` 再授权一次，必须带上来源会话与 token；否则会被
-            // 判为 missing_token。宿主终端调用没有 token，这里如实留空。
+            // `request` 是从 argv 重建的，不含调用方凭据。创建话题的旧式
+            // `topic-created` 通知仍经 `sendAunMsg` 走托管授权；宿主终端没有 token，
+            // 这类通知会按尽力而为处理。`topic.renamed` 是已有的系统事件，发送器
+            // 对它沿用系统事件豁免，因此菜单改名不需要伪造托管任务凭据。
             if (token) {
                 request.delegationToken = token;
                 if (incoming.delegationCommandHash)
@@ -58,15 +60,16 @@ export function createThreadOperationExecutor(dependencies) {
                 }
                 // `current` 必须先解析成具体 threadId，后续判断（日志、通知）都依赖它。
                 // 群主会话改名的限制不在这里做：普通成员允许改自己的本地称呼，
-                // 只是不发通知（见 thread-operation.ts 的 topic-renamed 分支）。
+                // 只是不发通知（见 thread-operation.ts 的 topic.renamed 分支）。
                 if (request.ref === 'current') {
                     const indexed = threadService.resolveCurrentThread(request.selfAid, session.id);
                     request.peer = indexed?.peer ?? currentPeer;
-                    request.threadId = indexed?.threadId ?? session.threadId ?? undefined;
+                    // 主会话保持 ''（rename 等分支用 `threadId === undefined` 判缺参，'' 才表示主话题）。
+                    request.threadId = indexed?.threadId ?? sessionTopicThreadId(session) ?? '';
                     request.sessionId = session.id;
                 }
                 const globalOperation = ['list-peers', 'check-index', 'rebuild-index'].includes(request.op);
-                const decision = authorizeOperation({
+                const decision = await authorizeOperation({
                     source: 'agent-tool', subject,
                     intent: { operation: `ec.thread.${request.op}`, scope: globalOperation && !(relationOnly && request.op === 'list-peers') ? 'agent' : 'relation', source: 'agent-tool', args: { self: request.selfAid, peer: request.peer ?? currentPeer, peerKey: delegation.grant.peerKey } },
                     auditMetadata: { taskId: delegation.grant.taskId, messageId: delegation.grant.messageId },
@@ -89,7 +92,7 @@ export function createThreadOperationExecutor(dependencies) {
             // 被要求联系 C 时，查/建/写的是我与 C 的话题，不属于 G，也不该受 G 约束。
             // "只能操作自己数据"由 authorizeOperation 的 targetCurrentAgentOnly 负责。
             if (request.op.startsWith('summary-') && !request.sessionId) {
-                const target = request.threadId
+                const target = isTopicThreadId(request.threadId)
                     ? await threadService.showThread({ selfAid: request.selfAid, peer: request.peer, threadId: request.threadId })
                     : await threadService.showMainSession(request.selfAid, request.peer);
                 if (!target)

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

@@ -1,5 +1,42 @@
 import { logger } from '../../utils/logger.js';
 import { normalizeThreadPeer } from './thread-service.js';
+import { isMainSessionThreadId, isTopicThreadId } from './topic-id.js';
+/**
+ * Emit the existing cross-device rename event after a local rename succeeds.
+ * Storage stays in ThreadService; transport stays in the operation layer.
+ */
+export async function notifyThreadRename(input) {
+    logger.info(`[Thread] notifyRename called: peer=${input.peer} threadId=${input.threadId} changed=${input.result.changed} nameUpdatedAt=${input.result.nameUpdatedAt} sendSystemMsg=${!!input.sendSystemMsg}`);
+    if (!input.sendSystemMsg || !input.result.changed || !input.result.nameUpdatedAt)
+        return;
+    const peerKind = input.result.peerKind
+        ?? (isMainSessionThreadId(input.threadId)
+            ? undefined
+            : input.threadService.findInIndex(input.selfAid, input.peer, input.threadId)?.peerKind)
+        ?? 'private';
+    // 群主话题是“本地对群的称呼”，发给群只会覆盖所有人的本地叫法。
+    if (peerKind === 'group' && isMainSessionThreadId(input.threadId))
+        return;
+    try {
+        await input.sendSystemMsg({
+            from: input.selfAid,
+            to: input.peer,
+            threadId: input.threadId,
+            topicName: input.result.name,
+            peerKind,
+            kind: 'topic.renamed',
+            nameUpdatedAt: input.result.nameUpdatedAt,
+            originSessionId: input.originSessionId,
+            delegationToken: input.delegationToken,
+            delegationCommandHash: input.delegationCommandHash,
+        });
+    }
+    catch (error) {
+        // 通知失败不影响本地改名，但必须留痕：静默失败会让“改名同步”
+        // 看起来像没实现（实测已踩过）。
+        logger.warn(`[Thread] topic.renamed notification failed: peer=${input.peer} thread=${input.threadId} name=${JSON.stringify(input.result.name)} error=${error instanceof Error ? error.message : String(error)}`);
+    }
+}
 export function executeThreadOperation(request, threadService, sendSystemMsg) {
     return _executeThreadOperation(request, threadService, sendSystemMsg);
 }
@@ -38,7 +75,7 @@ async function _executeThreadOperation(request, threadService, sendSystemMsg) {
             case 'show': {
                 let peer = request.peer;
                 let threadId = request.threadId;
-                if ((!peer || !threadId) && request.sessionId) {
+                if ((!peer || threadId === undefined) && request.sessionId) {
                     const resolved = threadService.resolveCurrentThread(selfAid, request.sessionId);
                     if (resolved) {
                         peer = resolved.peer;
@@ -47,8 +84,8 @@ async function _executeThreadOperation(request, threadService, sendSystemMsg) {
                 }
                 if (!peer)
                     return { ok: false, code: 'MISSING_ARGS', error: 'peer is required' };
-                // peer-only ref (no threadId) → show main session
-                if (!threadId) {
+                // 主话题（空 / `main` / 规范 id）→ 读该关系的主会话
+                if (!isTopicThreadId(threadId)) {
                     const result = await threadService.showMainSession(selfAid, peer);
                     if (!result)
                         return { ok: false, code: 'NOT_FOUND', error: `与 ${peer} 无活跃主会话` };
@@ -134,7 +171,7 @@ async function _executeThreadOperation(request, threadService, sendSystemMsg) {
             case 'rename': {
                 let peer = request.peer;
                 let threadId = request.threadId;
-                if ((!peer || !threadId) && request.sessionId) {
+                if ((!peer || threadId === undefined) && request.sessionId) {
                     const resolved = threadService.resolveCurrentThread(selfAid, request.sessionId);
                     if (resolved) {
                         peer = resolved.peer;
@@ -146,65 +183,49 @@ async function _executeThreadOperation(request, threadService, sendSystemMsg) {
                     return { ok: false, code: 'MISSING_ARGS', error: 'peer, threadId and name required' };
                 }
                 const result = await threadService.renameThread({ selfAid, peer, threadId, name: request.name });
-                // 改名通知（尽力而为，失败不影响本地改名）：
-                //   - 私聊主会话/子话题：通知对端 agent 或人类，便于其按名字选择话题。
-                //   - 群子话题：发到群，所有成员同步。
-                //   - 群主会话：不发（只有 admin/owner 能改，且它是本地对群本身的称呼）。
-                if (sendSystemMsg && result.changed && result.nameUpdatedAt) {
-                    const entry = threadId ? threadService.findInIndex(selfAid, peer, threadId) : undefined;
-                    const peerKind = entry?.peerKind ?? (request.peerKind ?? 'private');
-                    const isGroupMain = peerKind === 'group' && !threadId;
-                    if (!isGroupMain) {
-                        try {
-                            await sendSystemMsg({
-                                from: selfAid,
-                                to: peer,
-                                threadId: threadId ?? '',
-                                topicName: result.name,
-                                peerKind,
-                                kind: 'topic-renamed',
-                                nameUpdatedAt: result.nameUpdatedAt,
-                                originSessionId: request.sessionId,
-                                delegationToken: request.delegationToken,
-                                delegationCommandHash: request.delegationCommandHash,
-                            });
-                        }
-                        catch (error) {
-                            // 通知失败不影响本地改名，但必须留痕：静默失败会让"改名同步"
-                            // 看起来像没实现（实测已踩过）。
-                            logger.warn(`[Thread] topic-renamed notification failed: peer=${peer} thread=${threadId ?? 'main'} name=${JSON.stringify(result.name)} error=${error instanceof Error ? error.message : String(error)}`);
-                        }
-                    }
-                }
+                // 改名通知走统一出口（同名、失败和群主话题不发）。
+                await notifyThreadRename({
+                    selfAid,
+                    peer,
+                    threadId: threadId ?? '',
+                    result,
+                    threadService,
+                    sendSystemMsg,
+                    originSessionId: request.sessionId,
+                    delegationToken: request.delegationToken,
+                    delegationCommandHash: request.delegationCommandHash,
+                });
                 return { ok: true, result };
             }
             case 'label': {
                 let peer = request.peer;
                 let threadId = request.threadId;
-                if ((!peer || !threadId) && request.sessionId) {
+                if ((!peer || threadId === undefined) && request.sessionId) {
                     const resolved = threadService.resolveCurrentThread(selfAid, request.sessionId);
                     if (resolved) {
                         peer = resolved.peer;
                         threadId = resolved.threadId;
                     }
                 }
-                if (!peer || !threadId)
-                    return { ok: false, code: 'MISSING_ARGS', error: 'peer and threadId required' };
+                if (!peer || !isTopicThreadId(threadId)) {
+                    return { ok: false, code: 'MISSING_ARGS', error: '标签只适用于话题（主话题没有标签）' };
+                }
                 await threadService.labelThread({ selfAid, peer, threadId, label: request.label ?? null });
                 return { ok: true };
             }
             case 'status': {
                 let peer = request.peer;
                 let threadId = request.threadId;
-                if ((!peer || !threadId) && request.sessionId) {
+                if ((!peer || threadId === undefined) && request.sessionId) {
                     const resolved = threadService.resolveCurrentThread(selfAid, request.sessionId);
                     if (resolved) {
                         peer = resolved.peer;
                         threadId = resolved.threadId;
                     }
                 }
-                if (!peer || !threadId || !request.topicStatus)
-                    return { ok: false, code: 'MISSING_ARGS', error: 'peer, threadId and topicStatus required' };
+                if (!peer || !isTopicThreadId(threadId) || !request.topicStatus) {
+                    return { ok: false, code: 'MISSING_ARGS', error: '状态只适用于话题（主话题没有业务状态）' };
+                }
                 await threadService.statusThread({ selfAid, peer, threadId, topicStatus: request.topicStatus });
                 return { ok: true };
             }
@@ -221,15 +242,16 @@ async function _executeThreadOperation(request, threadService, sendSystemMsg) {
             case 'delete': {
                 let peer = request.peer;
                 let threadId = request.threadId;
-                if ((!peer || !threadId) && request.sessionId) {
+                if ((!peer || threadId === undefined) && request.sessionId) {
                     const resolved = threadService.resolveCurrentThread(selfAid, request.sessionId);
                     if (resolved) {
                         peer = resolved.peer;
                         threadId = resolved.threadId;
                     }
                 }
-                if (!peer || !threadId)
-                    return { ok: false, code: 'MISSING_ARGS', error: 'peer and threadId required' };
+                if (!peer || !isTopicThreadId(threadId)) {
+                    return { ok: false, code: 'NOT_A_TOPIC', error: '只能删除话题（主话题不可删除）' };
+                }
                 await threadService.deleteThread(selfAid, peer, threadId);
                 return { ok: true };
             }
@@ -251,7 +273,7 @@ async function _executeThreadOperation(request, threadService, sendSystemMsg) {
                 if (!name)
                     return { ok: true, result };
                 // 解析改名目标：主会话（threadId 为空串）不进索引，靠 peer + sessionId 定位；
-                // 子话题优先用索引里的 peer/threadId，索引查不到时退回请求里带的 ref。
+                // 话题优先用索引里的 peer/threadId，索引查不到时退回请求里带的 ref。
                 const indexed = threadService.readThreadIndex(selfAid).threads.find(t => t.sessionId === request.sessionId);
                 const peer = request.peer ?? indexed?.peer;
                 const threadId = request.threadId ?? indexed?.threadId;
@@ -264,6 +286,19 @@ async function _executeThreadOperation(request, threadService, sendSystemMsg) {
                 }
                 try {
                     const renamed = await threadService.renameThread({ selfAid, peer, threadId: threadId ?? '', name });
+                    // 总结伴随的真实改名同样要通知对端：与 `ec thread rename` 共用同一出口，
+                    // 否则 App 与对端索引只在 CLI rename 路径同步，summary set 改名静默。
+                    await notifyThreadRename({
+                        selfAid,
+                        peer,
+                        threadId: threadId ?? '',
+                        result: renamed,
+                        threadService,
+                        sendSystemMsg,
+                        originSessionId: request.sessionId,
+                        delegationToken: request.delegationToken,
+                        delegationCommandHash: request.delegationCommandHash,
+                    });
                     return { ok: true, result: { ...result, renamedTo: renamed.name, renamedChanged: renamed.changed } };
                 }
                 catch (e) {

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

@@ -1,18 +1,57 @@
 import { sameGroupAid } from '../../aun/group/identity.js';
 import { ThreadService } from './thread-service.js';
+import { isMainSessionThreadId, resolveThreadRef } from './topic-id.js';
 /**
  * 解析 `--thread` 跨话题发送的目标话题。
  *
- * 话题必须存在于发送方本端索引、属于 AUN 渠道、peerKind 与发送 scope 一致；
- * 给出 target 时还必须与话题 peer 相同（群按群 AID 规范化比较）。
- * 返回 undefined 表示该 thread 不能作为跨话题路由依据。
+ * 输入是**话题引用**：话题 id、主话题 id（`main:<a>:<b>`），或历史写法
+ * `<peer>/<id>`。目标对端由引用自身推出（话题取索引条目，主话题取 id 里的
+ * 另一端），`target` 仅用于矛盾校验——写了就必须与引用一致。
+ *
+ * 话题必须存在于本端：话题查索引，主话题查该关系的 active session。
+ * 返回 undefined 表示该引用不能作为跨话题路由依据。
  */
-export function resolveThreadRouteTarget(selfAid, threadId, scope, target) {
-    if (!selfAid || !threadId)
+export function resolveThreadRouteTarget(selfAid, threadRef, scope, target) {
+    if (!selfAid)
+        return undefined;
+    const normalizedSelf = selfAid.replace(/^@/, '');
+    const resolved = resolveThreadRef(threadRef, normalizedSelf);
+    if (resolved.kind === 'invalid' || resolved.kind === 'current')
         return undefined;
+    // 主话题：对端只能从引用里来。旧的空串/`main` 没有对端信息，只能靠显式的
+    // target 补齐（保留给尚未归一的历史调用方）。
+    if (resolved.kind === 'main' || isMainSessionThreadId(threadRef)) {
+        const peerFromRef = resolved.kind === 'main' ? resolved.peer : undefined;
+        const effectiveTarget = peerFromRef ?? target;
+        if (!effectiveTarget)
+            return undefined;
+        if (target !== undefined && peerFromRef !== undefined) {
+            const normalizedTarget = target.replace(/^@/, '');
+            const matches = scope === 'group'
+                ? sameGroupAid(peerFromRef, normalizedTarget)
+                : peerFromRef === normalizedTarget;
+            if (!matches)
+                return undefined;
+        }
+        let entry;
+        try {
+            entry = ThreadService.findMainSessionEntry(normalizedSelf, effectiveTarget);
+        }
+        catch {
+            return undefined;
+        }
+        if (!entry)
+            return undefined;
+        if ((entry.channelType ?? 'aun') !== 'aun')
+            return undefined;
+        if (entry.peerKind !== (scope === 'group' ? 'group' : 'private'))
+            return undefined;
+        return entry;
+    }
+    const threadId = resolved.threadId;
     let entry;
     try {
-        entry = ThreadService.findThreadById(selfAid.replace(/^@/, ''), threadId);
+        entry = ThreadService.findThreadById(normalizedSelf, threadId);
     }
     catch {
         return undefined;
@@ -23,6 +62,15 @@ export function resolveThreadRouteTarget(selfAid, threadId, scope, target) {
         return undefined;
     if (entry.peerKind !== (scope === 'group' ? 'group' : 'private'))
         return undefined;
+    // 引用里写了 `<peer>/<id>` 时，peer 必须与索引一致——不一致说明引用来自别处。
+    if (resolved.peer !== undefined) {
+        const normalizedPeer = resolved.peer.replace(/^@/, '');
+        const samePeer = scope === 'group'
+            ? sameGroupAid(entry.peer, normalizedPeer)
+            : entry.peer === normalizedPeer;
+        if (!samePeer)
+            return undefined;
+    }
     if (target === undefined)
         return entry;
     const normalizedTarget = target.replace(/^@/, '');