evolcore 0.0.33 → 0.0.35-test.0

package/dist/core/system-session/registry.js

@@ -0,0 +1,74 @@
+/**
+ * system-session/registry.ts — 系统会话模块注册表
+ *
+ * 只登记仓库内的模块，不做运行时动态加载、不读配置。
+ */
+import { SYSTEM_SESSION_TYPES } from './types.js';
+import { memorySystemSession } from './memory.js';
+const MODULES = new Map([
+    [memorySystemSession.type, memorySystemSession],
+]);
+if (SYSTEM_SESSION_TYPES.length !== MODULES.size || SYSTEM_SESSION_TYPES.some(type => !MODULES.has(type))) {
+    throw new Error('SYSTEM_SESSION_TYPES 与系统会话注册表不一致');
+}
+export function getSystemSessionModule(type) {
+    return MODULES.get(type);
+}
+export function isSystemSessionType(type) {
+    return !!type && MODULES.has(type);
+}
+/** 从 session.metadata 读出系统会话标记；存在但不合法时拒绝降级为普通会话。 */
+export function readSystemSessionMarker(metadata) {
+    const rawValue = metadata?.systemSession;
+    if (rawValue === undefined)
+        return undefined;
+    if (!rawValue || typeof rawValue !== 'object' || Array.isArray(rawValue)) {
+        throw new Error('系统会话标记格式非法');
+    }
+    const raw = rawValue;
+    if (typeof raw.type !== 'string' || typeof raw.subtype !== 'string') {
+        throw new Error('系统会话标记缺少 type 或 subtype');
+    }
+    const module = MODULES.get(raw.type);
+    if (!module)
+        throw new Error(`未注册的系统会话类型: ${raw.type}`);
+    if (!module.subtypes.includes(raw.subtype)) {
+        throw new Error(`系统会话 ${raw.type} 不支持 subtype: ${raw.subtype}`);
+    }
+    return { type: raw.type, subtype: raw.subtype };
+}
+/**
+ * 拉起前校验：类型与 subtype 已注册、runner 受支持。
+ * 不合法直接抛错，调用方不应降级成普通会话。
+ */
+export function assertSystemSessionLaunchable(marker, runner) {
+    const module = MODULES.get(marker.type);
+    if (!module)
+        throw new Error(`未注册的系统会话类型: ${marker.type}`);
+    if (!module.subtypes.includes(marker.subtype)) {
+        throw new Error(`系统会话 ${marker.type} 不支持 subtype: ${marker.subtype}`);
+    }
+    if (!module.supportedRunners.includes(runner)) {
+        throw new Error(`系统会话 ${marker.type} 不支持在 ${runner} 上运行（支持：${module.supportedRunners.join(', ')}）`);
+    }
+    return module;
+}
+/** 从 session.metadata 构造模块输入事实。 */
+export function buildSystemSessionContext(params) {
+    const m = params.metadata ?? {};
+    const str = (key) => (typeof m[key] === 'string' && m[key] ? m[key] : undefined);
+    const scope = str('memoryScope');
+    const batchDir = str('consolidationBatchDir');
+    return {
+        sessionId: params.sessionId,
+        subtype: params.marker.subtype,
+        selfAid: params.selfAid,
+        projectPath: params.projectPath,
+        ...(params.managedTempDir ? { managedTempDir: params.managedTempDir } : {}),
+        ...(str('peerKey') ? { peerKey: str('peerKey') } : {}),
+        ...(str('consolidationOwnerAid') ? { ownerAid: str('consolidationOwnerAid') } : {}),
+        ...(batchDir ? { batchDir } : {}),
+        ...(str('consolidationChatDir') ? { chatDir: str('consolidationChatDir') } : {}),
+        ...(scope === 'relation' || scope === 'agent' || scope === 'owner' ? { memoryScope: scope } : {}),
+    };
+}

package/dist/core/system-session/types.js

@@ -0,0 +1,14 @@
+/**
+ * system-session/types.ts — 系统会话模块接口
+ *
+ * 系统会话（记忆整理等）与角色体系无关：不带角色、不走角色权限判定。
+ * 路径、工具、ec 命令、manifest、runner 启动参数全部由对应类型的代码模块决定，
+ * 模块的结论就是最终结论，不可配置。
+ *
+ * 详见 docs/memory/system-session-plugin-design.md
+ */
+/**
+ * 已注册的系统会话类型。放在无依赖的 types.ts，供 eck / config 层判断而不引入模块实现；
+ * registry.ts 启动时校验与注册表一致。
+ */
+export const SYSTEM_SESSION_TYPES = ['memory'];

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

@@ -81,7 +81,12 @@ export function resolveThreadCommandArgv(argv) {
             if (pieces.length > 2 || !pieces[0] || pieces[1] === '')
                 throw new Error('Invalid thread reference');
             request.peer = normalizeThreadPeer(pieces[0]);
-            request.threadId = pieces[1];
+            // 主会话的 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');
         }

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

@@ -1,6 +1,5 @@
 import { trustedExecutionIdentityInput } from '../auth/agent-delegation.js';
 import { authorizeOperation, buildAuthSubject } from '../auth/auth-gateway.js';
-import { isManagementRole } from '../../config/builtin-roles.js';
 import { parsePeerKey } from '../relation/peer-identity.js';
 import { resolveThreadCommandArgv } from './command-parser.js';
 import { executeThreadOperation } from './thread-operation.js';
@@ -13,6 +12,16 @@ 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，这里如实留空。
+            if (token) {
+                request.delegationToken = token;
+                if (incoming.delegationCommandHash)
+                    request.delegationCommandHash = incoming.delegationCommandHash;
+                if (incoming.sessionId)
+                    request.sessionId = incoming.sessionId;
+            }
             let currentPeer;
             let relationOnly = false;
             if (token) {
@@ -38,12 +47,24 @@ export function createThreadOperationExecutor(dependencies) {
                 });
                 relationOnly = subject.dataScope === 'relation';
                 const readOnly = ['list', 'list-peers', 'show', 'history', 'check-index', 'summary-show', 'summary-log'].includes(request.op);
-                const management = isManagementRole(subject.role) || subject.processRole === 'fullaccess-run';
-                if (delegation.grant.chatType === 'group' && !management) {
-                    return { ok: false, code: 'NOT_ALLOWED', error: 'Group thread operations require an administrator role' };
+                // 话题数据是**本 agent 自己的**（`agents/<self>/data/threads/`），与当前
+                // 所在的关系（私聊对端 / 群）无关。因此：
+                //   - 触发场景的 chatType 不能决定能否操作话题：在群里被要求联系第三方，
+                //     查索引、建话题、写摘要都是对自己数据的操作，不涉及当前群。
+                //   - 建/改话题也不再要求管理员：member 建一个"我与 C"的话题与管理员无关。
+                // 保留的唯一硬约束：readonly 权限模式（visitor 兜底）不得写。
+                if (!readOnly && subject.permissionMode === 'readonly') {
+                    return { ok: false, code: 'NOT_ALLOWED', error: 'Thread changes require a writable task' };
+                }
+                // `current` 必须先解析成具体 threadId，后续判断（日志、通知）都依赖它。
+                // 群主会话改名的限制不在这里做：普通成员允许改自己的本地称呼，
+                // 只是不发通知（见 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;
+                    request.sessionId = session.id;
                 }
-                if (!readOnly && (!management || subject.permissionMode === 'readonly'))
-                    return { ok: false, code: 'NOT_ALLOWED', error: 'Thread changes require a writable administrator task' };
                 const globalOperation = ['list-peers', 'check-index', 'rebuild-index'].includes(request.op);
                 const decision = authorizeOperation({
                     source: 'agent-tool', subject,
@@ -54,12 +75,6 @@ export function createThreadOperationExecutor(dependencies) {
                     return { ok: false, code: decision.code, error: decision.reason };
                 if (relationOnly && globalOperation && request.op !== 'list-peers')
                     return { ok: false, code: 'SCOPE_MISMATCH', error: 'Index management requires Agent scope' };
-                if (request.ref === 'current') {
-                    const indexed = threadService.resolveCurrentThread(request.selfAid, session.id);
-                    request.peer = indexed?.peer ?? currentPeer;
-                    request.threadId = indexed?.threadId ?? session.threadId ?? undefined;
-                    request.sessionId = session.id;
-                }
             }
             else {
                 if (incoming.sessionId || incoming.delegationToken || incoming.localControl !== true)
@@ -69,8 +84,10 @@ export function createThreadOperationExecutor(dependencies) {
                 if (request.ref === 'current')
                     return { ok: false, code: 'INVALID_REQUEST', error: 'current requires a managed caller session' };
             }
-            if (relationOnly && request.peer && request.peer !== currentPeer)
-                return { ok: false, code: 'SCOPE_MISMATCH', error: 'Only the current relation can be targeted' };
+            // 话题操作的目标对端与"当前在哪个关系里被触发"是两个不同维度：
+            // 索引、话题会话、摘要全部落在本 agent 自己的数据目录下。在群 G 里
+            // 被要求联系 C 时，查/建/写的是我与 C 的话题，不属于 G，也不该受 G 约束。
+            // "只能操作自己数据"由 authorizeOperation 的 targetCurrentAgentOnly 负责。
             if (request.op.startsWith('summary-') && !request.sessionId) {
                 const target = request.threadId
                     ? await threadService.showThread({ selfAid: request.selfAid, peer: request.peer, threadId: request.threadId })
@@ -84,8 +101,8 @@ export function createThreadOperationExecutor(dependencies) {
             const response = await executeThreadOperation(request, threadService, dependencies.sendSystemMsg);
             if (response.ok && request.op === 'delete' && request.threadId)
                 dependencies.onDeleted?.(request.selfAid, request.threadId);
-            if (response.ok && relationOnly && request.op === 'list-peers')
-                response.result = { peers: response.result.peers.filter(entry => entry.peer === currentPeer) };
+            // list-peers 不再裁剪到当前对端：它就是本 agent 自己的对端目录索引，
+            // 跨话题协作的前提恰恰是先能看到"我和谁是过话题"。
             return response;
         }
         catch (error) {

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

@@ -1,3 +1,4 @@
+import { logger } from '../../utils/logger.js';
 import { normalizeThreadPeer } from './thread-service.js';
 export function executeThreadOperation(request, threadService, sendSystemMsg) {
     return _executeThreadOperation(request, threadService, sendSystemMsg);
@@ -118,6 +119,10 @@ async function _executeThreadOperation(request, threadService, sendSystemMsg) {
                             threadId: result.threadId,
                             topicName: result.name,
                             peerKind: request.peerKind ?? 'private',
+                            // 与 rename 相同：授权链需要托管上下文，宿主调用则留空（跳过通知）。
+                            originSessionId: request.sessionId,
+                            delegationToken: request.delegationToken,
+                            delegationCommandHash: request.delegationCommandHash,
                         });
                     }
                     catch {
@@ -136,9 +141,41 @@ async function _executeThreadOperation(request, threadService, sendSystemMsg) {
                         threadId = resolved.threadId;
                     }
                 }
-                if (!peer || !threadId || !request.name)
+                // threadId === '' 是主会话的合法写法（`<peer>/main`），不能被当成缺参。
+                if (!peer || threadId === undefined || !request.name) {
                     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)}`);
+                        }
+                    }
+                }
                 return { ok: true, result };
             }
             case 'label': {
@@ -206,35 +243,36 @@ async function _executeThreadOperation(request, threadService, sendSystemMsg) {
                 if (!request.sessionId || !request.content)
                     return { ok: false, code: 'MISSING_ARGS', error: 'sessionId and content required' };
                 // 覆盖游标由 service 自动记录（写入时刻话题最后一条消息的 ts），调用方不用传。
-                const result = threadService.setSummary(selfAid, request.sessionId, request.content, request.ifRev);
+                const result = await threadService.setSummary(selfAid, request.sessionId, request.content, request.ifRev);
                 // 顺带改名：总结时往往正好把话题主题想清楚了，一次命令写完更省事。
                 // 调用方（CLI / slash）保证 name 一定存在；`-` 表示"保持原标题不改"。
-                // 主会话没有话题名可改（threadId 为空），忽略该参数而不是报错。
                 const rawName = typeof request.name === 'string' ? request.name.trim() : '';
-                let name = rawName && rawName !== '-' ? rawName : undefined;
-                let threadId = request.threadId;
-                if (name && !threadId) {
-                    const resolved = threadService.resolveCurrentThread(selfAid, request.sessionId);
-                    threadId = resolved?.threadId;
+                const name = rawName && rawName !== '-' ? rawName : undefined;
+                if (!name)
+                    return { ok: true, result };
+                // 解析改名目标：主会话（threadId 为空串）不进索引，靠 peer + sessionId 定位；
+                // 子话题优先用索引里的 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;
+                if (!peer) {
+                    // 摘要已写入，改名目标无从确定——如实返回原因，别静默丢弃。
+                    return {
+                        ok: true,
+                        result: { ...result, renameError: '无法解析改名目标：缺少 peer' },
+                    };
                 }
-                let peer = request.peer;
-                if (name && threadId && !peer) {
-                    peer = threadService.readThreadIndex(selfAid).threads.find(t => t.threadId === threadId)?.peer;
+                try {
+                    const renamed = await threadService.renameThread({ selfAid, peer, threadId: threadId ?? '', name });
+                    return { ok: true, result: { ...result, renamedTo: renamed.name, renamedChanged: renamed.changed } };
                 }
-                if (name && threadId && peer) {
-                    try {
-                        const renamed = await threadService.renameThread({ selfAid, peer, threadId, name });
-                        return { ok: true, result: { ...result, renamedTo: renamed.name, renamedChanged: renamed.changed } };
-                    }
-                    catch (e) {
-                        // 摘要已写入，改名失败不回滚——如实返回，让调用方知道只有改名这步没成
-                        return {
-                            ok: true,
-                            result: { ...result, renameError: e?.message ?? String(e) },
-                        };
-                    }
+                catch (e) {
+                    // 摘要已写入，改名失败不回滚——如实返回，让调用方知道只有改名这步没成
+                    return {
+                        ok: true,
+                        result: { ...result, renameError: e?.message ?? String(e) },
+                    };
                 }
-                return { ok: true, result };
             }
             case 'summary-log': {
                 if (!request.sessionId)