evolcore 0.0.34 → 0.0.35

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

@@ -16,19 +16,21 @@
  * 详见 docs/memory/system-session-plugin-design.md §5-§8
  */
 import path from 'path';
+import fs from 'fs';
 import { resolveRoot } from '../../paths.js';
 import { parseCodexToolCommand } from '../permission/ec-command-parser.js';
 import { canonicalToolCall } from '../permission/tool-canonical.js';
 import { checkReadonly } from '../permission/tool-policy.js';
+import { analyzeReadonlyShellQuery } from '../permission/readonly-shell-query.js';
 import { CONSOLIDATION_MODES } from '../memory/consolidation-context.js';
 import { feedbackFilePath } from '../memory/consolidation-ops-records.js';
 import { checkWriteTargets } from './grants.js';
 export const MEMORY_SESSION_DENY_MESSAGE = '整理会话不允许执行此命令';
 const MEMORY_MANIFEST = 'eck_manifest.memory.json';
 const ALLOWED_MEMORY_SUBCOMMANDS = new Set(['create', 'update', 'archive']);
-const BASH_COMMAND_RULE = 'Bash 只允许单条 `ec memory create|update|archive`，或落在本次整理目录内的只读查询'
-    + '（不能拼接其他命令；正文含特殊字符时用单引号包住）。读文件请用 Read / Glob / Grep；'
-    + '整理反馈用文件写入工具写到任务书指定的反馈文件。';
+const BASH_COMMAND_RULE = 'Bash 只允许两类命令：单条 `ec memory create|update|archive`（不能与其他命令拼接）；'
+    + '或路径落在可读根内、可证明只读的查询（如 ls / cat / grep），多条查询可用 `&&` 或 `;` 连接，最多 8 段。'
+    + '读文件请用 Read / Glob / Grep；整理反馈用文件写入工具写到任务书指定的反馈文件。';
 function layerDir(layer, ctx) {
     const root = resolveRoot();
     if (layer === 'agent')
@@ -68,7 +70,22 @@ export function memoryReadRoots(ctx) {
             add(...consolidated('relation'), messages);
             break;
         case 'forget':
-            if (ctx.memoryScope) {
+            if (ctx.memoryScope === 'agent') {
+                // agent 级 forget：给所有 relation 的 consolidated 目录 + agent 自身的 consolidated
+                const relationsRoot = path.join(resolveRoot(), 'agents', ctx.selfAid, 'relations');
+                if (fs.existsSync(relationsRoot)) {
+                    for (const peerKey of fs.readdirSync(relationsRoot)) {
+                        const consolidatedDir = path.join(relationsRoot, peerKey, 'memory', 'consolidated');
+                        const indexPath = path.join(relationsRoot, peerKey, 'memory', 'MEMORY.md');
+                        if (fs.existsSync(consolidatedDir)) {
+                            add(consolidatedDir, indexPath);
+                        }
+                    }
+                }
+                add(...consolidated('agent'));
+            }
+            else if (ctx.memoryScope) {
+                // relation / owner 级 forget：只给当前层级
                 add(...consolidated(ctx.memoryScope));
                 if (ctx.memoryScope === 'relation')
                     add(messages);
@@ -100,19 +117,18 @@ function shellIssueRemedy(issue) {
         case 'unsafe-expansion':
             return '自由文本参数（--desc、正文、--keywords）里的反引号或 `$` 出现在双引号内，'
                 + '会被 shell 当作命令替换或变量展开，所以无法确认它实际会执行什么。'
-                + '请把这些参数改用单引号包住（如 --desc \'……\'）。'
-                + '注意单引号内部不能再出现单引号本身，正文可以跨多行。';
+                + '请把这些参数改用单引号包住（如 --desc \'……\'）；'
+                + '若正文本身含单引号，改用 $\'…\' 语法传入（支持 \\n \\t \\\\ \\\'）。';
         case 'invalid-quote':
-            return '单引号包裹的正文里出现了单引号本身，导致引号提前闭合、命令无法解析。'
-                + '正文里不要写半角撇号（ASCII 0x27）：改用 `ʼ`（U+02BC）或 `＇`（U+FF07）代替，'
-                + '或换一种说法避开这个字符。不要尝试转义——'
-                + '单引号内无法转义单引号，转义与拼接一律被拒。';
+            return '命令引号未闭合或存在错误嵌套。'
+                + '普通单引号内部不能再出现单引号——含单引号的正文改用 $\'…\' 语法：'
+                + '用 \\\' 转义内部的单引号，如 $\'it\\\'s fine\'。';
         case 'structural-newline':
-            return '命令里存在未闭合的换行结构。把正文放进单引号内即可直接换行。';
+            return '命令里存在未闭合的换行结构。把正文放进单引号或 $\'…\' 内即可直接换行（$\'…\' 支持 \\n 转义）。';
         case 'shell-composition':
             return '命令里含有 shell 拼接、管道或重定向（`;` `&&` `|` `$()` 等）。整理会话只允许单条 ec memory 命令。';
         case 'unsupported-escape':
-            return '命令里使用了不受支持的转义写法。请改用单引号包住正文，避免转义。';
+            return '命令里使用了不受支持的转义写法。请改用单引号包住正文；若正文含单引号，改用 $\'…\' 语法传入。';
         case 'lossy-cmd-shim':
             return '命令经过 Windows cmd 包装后无法无歧义还原。请把正文改成不含换行的单条命令。';
         case 'untrusted-shell':
@@ -167,23 +183,74 @@ function checkShell(input, ctx) {
     const readonly = checkReadWithinMatrix('Bash', input, ctx);
     if (readonly.behavior === 'allow')
         return { allow: true };
-    if (!parsed.ok) {
-        const rawCommand = typeof input.command === 'string' ? input.command : '';
-        const remedy = shellIssueRemedy(parsed.issue);
-        if (looksLikeMemoryCommand(rawCommand) && remedy) {
+    const rawCommand = typeof input.command === 'string' ? input.command : '';
+    // ec 命令按 ec 解析器归因；ec 解析器的 issue 只描述 ec 命令，不能拿来解释普通 shell 查询
+    if (looksLikeMemoryCommand(rawCommand)) {
+        const remedy = parsed.ok ? undefined : shellIssueRemedy(parsed.issue);
+        if (remedy) {
             return deny('memory_session_command_forbidden', `这条命令本身就是 \`ec memory\`，但未能解析成单条字面命令。${remedy}`);
         }
+        return deny('memory_session_command_forbidden', `${BASH_COMMAND_RULE} 具体原因：ec memory 只允许 create / update / archive 三个子命令。`);
+    }
+    if ((parsed.ok && parsed.argv[0] === 'ec') || looksLikeEcCommand(rawCommand)) {
+        return deny('memory_session_command_forbidden', `${BASH_COMMAND_RULE} 具体原因：整理会话不能执行 ec memory create / update / archive 以外的 ec 命令。`);
+    }
+    // 普通 shell 查询：原因取自只读判定本身
+    return deny('memory_session_command_forbidden', `${BASH_COMMAND_RULE} 具体原因：${readonlyDenialHint(rawCommand, readonly.policyCode, ctx)}`);
+}
+function looksLikeEcCommand(command) {
+    return /^\s*ec(?:\.cmd|\.exe|\.ps1)?\s/.test(command);
+}
+/** 只读查询被拒的原因：与 checkReadonly 的判定分支一一对应。 */
+function readonlyDenialHint(command, policyCode, ctx) {
+    switch (policyCode) {
+        case 'readonly_workspace_escape':
+            return '命令可证明只读，但读取的路径不在可读根内。用任务书「可读根」列出的绝对路径；相对路径按会话 cwd 解析，cwd 本身不可读。';
+        case 'readonly_h_class_read':
+        case 'readonly_l_class_read':
+            return '命令读取了受保护路径，整理会话不能读。';
+        default:
+            break;
+    }
+    const analysis = analyzeReadonlyShellQuery(command, { managedTempDir: ctx.managedTempDir });
+    if (analysis.kind !== 'unproven')
+        return '命令无法证明只读。';
+    switch (analysis.reason) {
+        case 'unsupported-shell-structure':
+            return '命令含有不支持的 shell 结构：后台执行 `&`、`||`、输入重定向 `<`、换行，'
+                + '或除 `2>/dev/null` 以外的重定向（如 `2>&1`、`> file`），或连接段数、管道级数超限。'
+                + '多条查询只能用 `&&` 或 `;` 连接，最多 8 段。';
+        case 'non-literal-command':
+            return '命令参数不是字面量：未加引号的通配符（`*` `?` `[`）、变量 `$`、命令替换或无法解析的引号，'
+                + '静态确定不了会读哪些文件。列文件请用 Glob 并给绝对 path。';
+        case 'unsupported-command-or-option':
+            return '命令或选项不在只读查询白名单内。不需要 `cd`：把绝对路径直接写进命令里。'
+                + '读文件用 Read，列文件用 Glob，搜索用 Grep。';
+        case 'unsupported-pipeline-filter':
+            return '管道 `|` 后面的命令不是纯 stdin 过滤命令。';
+        case 'pipeline-filter-must-use-stdin':
+            return '管道 `|` 后面的过滤命令只能处理上一级的输出，不能再带文件路径参数。';
+        default:
+            return `命令无法证明只读（${analysis.reason}）。`;
     }
-    return deny('memory_session_command_forbidden', BASH_COMMAND_RULE);
 }
 function checkTool(rawToolName, input, ctx) {
     const call = canonicalToolCall(rawToolName, input);
     switch (call.access) {
         case 'read': {
             const result = checkReadWithinMatrix(call.name, input, ctx);
-            return result.behavior === 'allow'
-                ? { allow: true }
-                : deny(result.policyCode ?? 'memory_session_read_outside_matrix', '只能读取本次整理的批次目录、对应记忆目录与本对话流水');
+            if (result.behavior !== 'allow') {
+                // 给出更具体的提示
+                let hint = '';
+                if (call.name === 'Glob' && !input.path) {
+                    hint = '。Glob 需要传绝对路径给 path 参数（不传时起点落在 cwd，整理会话的 cwd 不可读）';
+                }
+                else if (call.name === 'Grep' && !input.path) {
+                    hint = '。Grep 需要传绝对路径给 path 参数';
+                }
+                return deny(result.policyCode ?? 'memory_session_read_outside_matrix', `只能读取本次整理的批次目录、对应记忆目录与本对话流水${hint}`);
+            }
+            return { allow: true };
         }
         case 'write':
             // 引号内恰好出现 apply_patch 字样的 ec memory 命令可能被保守识别成 shell 写入，先按 ec 命令认定

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)