evolcore 0.0.32 → 0.0.34

package/dist/core/message/subtask-tool-projection.js

@@ -0,0 +1,140 @@
+/**
+ * Runner 子任务（Claude 后台任务/子智能体/工作流、Codex 子智能体）的出站投影。
+ *
+ * 子任务本身就是某次工具调用的执行过程：Claude 的 task_started / task_notification
+ * 都带来源工具的 tool_use_id。实测两种时序（events.log）：
+ * - 前台：tool_use → task_started → task_notification → 真实 tool_result（数毫秒后）
+ * - 后台：tool_use → task_started → 占位 tool_result（"running in background"）→ … → task_notification
+ *
+ * 因此有来源工具时，子任务不再单独出卡片，而是**归拢到来源工具的 tool_result**：
+ * 终态合并进那条 tool_result（见 foldSubtaskTerminal），后台场景先扣住占位结果，等终态再发。
+ * 渲染器负责扣留与合并（IMRenderer.beginParentSubtask / endParentSubtask）。
+ *
+ * 没有来源工具（如 Codex 子智能体只有子线程 ID）时，退回合成卡片：
+ * 开始一条 tool_call，终态一条 tool_result，共用 call_id = subtask-<taskId>。
+ */
+/** 合成 call_id 前缀，避免与真实工具调用 ID 相撞。 */
+const SUBTASK_CALL_ID_PREFIX = 'subtask';
+/** 描述作为命令摘要展示时的字符上限。 */
+const SHORT_DESCRIPTION_MAX_CHARS = 120;
+/** 终态摘要作为 tool_result.result 展示时的字符上限。 */
+const RESULT_SUMMARY_MAX_CHARS = 500;
+/** 无来源工具时，同一子任务开始与终态共用的合成 call_id。 */
+export function subtaskCallId(taskId) {
+    return `${SUBTASK_CALL_ID_PREFIX}-${taskId}`;
+}
+/** 子任务在工具卡片上的显示名（仅用于合成卡片或拿不到来源工具名时）。 */
+export function subtaskToolName(input) {
+    if (input.taskKind === 'agent')
+        return input.subagentType || 'Agent';
+    if (input.taskKind === 'workflow')
+        return 'Workflow';
+    if (input.taskType === 'local_bash')
+        return 'Bash';
+    return input.taskType || 'Task';
+}
+function collapse(text) {
+    return text ? text.replace(/\s+/g, ' ').trim() : '';
+}
+function truncate(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    return `${text.slice(0, maxChars)}…`;
+}
+/** 把描述压成一行短摘要：去掉换行与多余空白，超长截断。 */
+export function shortenSubtaskDescription(description) {
+    return truncate(collapse(description), SHORT_DESCRIPTION_MAX_CHARS);
+}
+function formatDuration(durationMs) {
+    if (typeof durationMs !== 'number' || !Number.isFinite(durationMs) || durationMs <= 0)
+        return '';
+    if (durationMs < 1000)
+        return `${Math.round(durationMs)}ms`;
+    return `${Math.round(durationMs / 1000)}s`;
+}
+/** 终态文案。状态由 ok/detail_code 表达，客户端不需要解析正文。 */
+export function subtaskStatusText(status, durationMs) {
+    const duration = formatDuration(durationMs);
+    const label = status === 'completed' ? '子任务完成'
+        : status === 'failed' ? '子任务失败'
+            : status === 'killed' ? '子任务已终止'
+                : '子任务已停止';
+    return duration ? `${label} (${duration})` : label;
+}
+/**
+ * 把子任务终态合并进来源工具的 tool_result。
+ *
+ * - ok：工具结果与子任务都成功才为 true。子任务失败/停止/终止时一律 false——实测存在
+ *   "任务 failed、工具结果 isError=false" 的组合，不能用工具的成功覆盖子任务的失败。
+ * - 工具结果已带错误分类时保留原分类；工具成功而子任务失败时补 EXECUTION_FAILED。
+ *   停止与终止不是执行失败，只用 detail_code 区分。
+ * - 正文、result、text 保留来源工具原值；子任务耗时更长（后台任务）时以子任务为准。
+ */
+export function foldSubtaskTerminal(item, terminal) {
+    if (item.kind !== 'tool_result')
+        return item;
+    const merged = { ...item };
+    if (typeof terminal.durationMs === 'number' && terminal.durationMs > (merged.duration_ms ?? 0)) {
+        merged.duration_ms = terminal.durationMs;
+    }
+    if (terminal.status === 'completed')
+        return merged;
+    merged.ok = false;
+    merged.detail_code ??= `subtask_${terminal.status}`;
+    if (!merged.error_code && terminal.status === 'failed')
+        merged.error_code = 'EXECUTION_FAILED';
+    if (!merged.error) {
+        const summary = collapse(terminal.summary);
+        merged.error = summary ? truncate(summary, RESULT_SUMMARY_MAX_CHARS) : subtaskStatusText(terminal.status);
+    }
+    return merged;
+}
+function buildArguments(input, shortDescription) {
+    const args = {
+        task_id: input.taskId,
+        subtask_kind: input.taskKind,
+    };
+    if (shortDescription)
+        args.command = shortDescription;
+    if (input.taskType)
+        args.task_type = input.taskType;
+    if (input.subagentType)
+        args.subagent_type = input.subagentType;
+    if (input.workflowName)
+        args.workflow_name = input.workflowName;
+    return args;
+}
+/** 无来源工具的子任务开始 → 合成 tool_call。 */
+export function projectSubtaskStarted(input) {
+    const shortDescription = shortenSubtaskDescription(input.description);
+    return {
+        kind: 'tool_call',
+        call_id: subtaskCallId(input.taskId),
+        name: subtaskToolName(input),
+        arguments: buildArguments(input, shortDescription),
+        text: shortDescription,
+    };
+}
+/**
+ * 子任务终态 → 独立 tool_result。
+ *
+ * 用于两种情况：无来源工具的合成卡片；或来源工具卡片已在本轮之外/已提前释放，
+ * 只能补发一条同 call_id 的终态结果来更新那张卡片。
+ */
+export function projectSubtaskTerminal(input) {
+    const shortDescription = shortenSubtaskDescription(input.description);
+    // 与描述比较用未截断的折叠文本：local_bash 未给 description 时 SDK 会把整条命令
+    // 同时塞进 description 和 summary，两者只是截断长度不同，仍属同一段文字。
+    const rawSummary = collapse(input.summary);
+    const summary = rawSummary ? truncate(rawSummary, RESULT_SUMMARY_MAX_CHARS) : '';
+    const base = {
+        kind: 'tool_result',
+        call_id: input.callId ?? subtaskCallId(input.taskId),
+        name: input.toolName ?? subtaskToolName(input),
+        ok: true,
+        text: `${subtaskStatusText(input.status, input.durationMs)}${shortDescription ? ` · ${shortDescription}` : ''}`,
+    };
+    if (summary && rawSummary !== collapse(input.description))
+        base.result = summary;
+    return foldSubtaskTerminal(base, { status: input.status, summary, durationMs: input.durationMs });
+}

package/dist/core/model/catalog-service.js

@@ -13,14 +13,19 @@ export const CATALOG_ROUTE_TIMEOUT_MS = 15_000;
  * 否则旧规则写下的持久化快照与新快照无法区分，会继续被服务。
  * v2：保留上下文窗口后缀（`claude-opus-5[1m]` 不再被折叠成基础 ID）。
  * v3：保留 Codex 上游声明的 max effort，重新获取旧快照中过滤掉的能力。
+ * v4：统一缺失 effort 元数据时的 transport fallback，并记录来源。
  */
-export const CATALOG_SNAPSHOT_VERSION = 3;
+export const CATALOG_SNAPSHOT_VERSION = 4;
+export const CONFIGURABLE_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max'];
 export const TRANSPORT_EFFORTS = {
     claude: ['low', 'medium', 'high', 'xhigh', 'max'],
     codex: ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'],
     ecagent: ['minimal', 'low', 'medium', 'high', 'xhigh', 'max'],
     gemini: [],
 };
+export function configurableEfforts(baseagent, efforts = TRANSPORT_EFFORTS[baseagent] ?? []) {
+    return efforts.filter((effort) => CONFIGURABLE_EFFORTS.includes(effort) && (TRANSPORT_EFFORTS[baseagent] ?? []).includes(effort));
+}
 function stable(value) {
     if (Array.isArray(value))
         return `[${value.map(stable).join(',')}]`;
@@ -93,10 +98,7 @@ const BUILTIN_IDS = {
     gemini: ['gemini-2.5-pro', 'gemini-2.5-flash', 'gemini-2.5-flash-lite'],
 };
 export function builtinCatalog(baseagent) {
-    return (BUILTIN_IDS[baseagent] ?? []).map(id => ({ id, verification: 'unverified',
-        ...(baseagent === 'codex' ? { reasoningLevels: ['low', 'medium', 'high', 'xhigh'] } : {}),
-        ...(/^claude-(opus|sonnet|haiku)-/.test(id) && baseagent === 'claude' ? { reasoningLevels: [...TRANSPORT_EFFORTS.claude] } : {}),
-    }));
+    return (BUILTIN_IDS[baseagent] ?? []).map(id => ({ id, verification: 'unverified' }));
 }
 export function deriveAliases(models, baseagent) {
     if (baseagent !== 'claude')
@@ -126,16 +128,19 @@ function compatible(model, baseagent) {
     return !model.protocols || !protocols[baseagent] || model.protocols.some(p => protocols[baseagent].includes(p));
 }
 function adapt(models, baseagent) {
-    const available = models.filter(m => compatible(m, baseagent)).map(m => ({ ...m,
-        ...(m.reasoningLevels ? { reasoningLevels: m.reasoningLevels.filter(e => TRANSPORT_EFFORTS[baseagent]?.includes(e)) } : {}),
-    }));
+    const available = models.filter(m => compatible(m, baseagent)).map(m => {
+        const reasoningLevels = configurableEfforts(baseagent, m.reasoningLevels);
+        const effortSource = reasoningLevels.length === 0 ? 'none'
+            : m.reasoningLevels === undefined ? 'transport-fallback' : 'catalog';
+        return { ...m, reasoningLevels, effortSource };
+    });
     const aliases = deriveAliases(available, baseagent);
     return [...Object.entries(aliases).filter(([id]) => !available.some(m => m.id === id)).map(([id, aliasFor]) => ({ ...available.find(m => m.id === aliasFor), id, aliasFor, owned_by: 'alias' })), ...available];
 }
 export function resolveCatalogModel(snapshot, model) { return snapshot.models.find(m => m.id === model)?.aliasFor ?? model; }
 export function catalogEfforts(snapshot, model, baseagent) {
     const entry = snapshot.models.find(m => m.id === resolveCatalogModel(snapshot, model));
-    return entry?.reasoningLevels?.filter(e => TRANSPORT_EFFORTS[baseagent]?.includes(e)) ?? [];
+    return entry ? configurableEfforts(baseagent, entry.reasoningLevels) : [];
 }
 export function assertCatalogSelectable(snapshot) {
     if (snapshot.diagnostics.some(d => d.code === 'AUTH_FAILED'))
@@ -288,7 +293,7 @@ export class ModelCatalogService {
             // suggestions; never let it attest gateway membership for another key.
             for (const [family, id] of Object.entries(aliases))
                 if (typeof id === 'string' && /^(opus|sonnet|haiku)$/.test(family) && new RegExp(`^claude-${family}-[A-Za-z0-9._-]+$`).test(id) && !models.some(m => m.id === id))
-                    models.unshift({ id, verification: 'unverified', reasoningLevels: [...TRANSPORT_EFFORTS.claude] });
+                    models.unshift({ id, verification: 'unverified' });
         }
         catch { /* No legacy data. */ }
         return models;
@@ -302,8 +307,8 @@ export class ModelCatalogService {
                 const models = await gatewayModels(context, this.options.fetch ?? fetch);
                 // Enrich only IDs the gateway listed. Native models never add/remove membership.
                 const native = context.baseagent === 'codex' && models.length ? await this.options.native?.(context).catch(() => null) : null;
-                const metadata = new Map((native ?? builtinCatalog(context.baseagent)).map(m => [m.id, m]));
-                const enriched = models.map(m => ({ ...m, ...(m.reasoningLevels === undefined && metadata.get(m.id)?.reasoningLevels ? { reasoningLevels: metadata.get(m.id).reasoningLevels } : {}) }));
+                const metadata = new Map((native ?? []).map(m => [m.id, m]));
+                const enriched = models.map(m => ({ ...m, ...(m.reasoningLevels === undefined && metadata.get(m.id)?.reasoningLevels !== undefined ? { reasoningLevels: metadata.get(m.id).reasoningLevels } : {}) }));
                 const result = this.make(context, 'gateway', 'fresh', enriched, diagnostics);
                 this.save(context, result);
                 return result;

package/dist/core/permission/ec-command-parser.js

@@ -663,7 +663,7 @@ const INLINE_TEXT_FLAGS = {
 };
 const MESSAGE_POSITIONAL_FLAGS = new Set([
     '--file', '--payload', '--as', '--content-type', '--text', '--transcript',
-    '--thread', '--return', '--title', '--description', '--text-from-file',
+    '--thread', '--title', '--description', '--text-from-file',
     '--handoff-context', '--aun-path', '--app', '--format', '--encrypt', '--no-encrypt',
 ]);
 /** Decode the EC inline text contract exactly once, after shell parsing. */
@@ -714,6 +714,77 @@ function decodePositionalText(argv, start, optionFlags) {
         argv[index] = decodeEvolcoreInlineText(value);
     }
 }
+// 取值为「逗号分隔、单项不含空格」的列表参数。aid、标签值、角色名里都不会有
+// 空格，所以按空格拆分是安全的。
+const MEMORY_LIST_FLAGS = new Set(['--tags', '--speakers']);
+const SEND_LIST_FLAGS = new Set(['--mention']);
+const FS_LIST_FLAGS = new Set(['--allow-roles']);
+// 取值可能含空格的列表参数，只能按逗号拆：关键词是自由文本，记忆路径是 config
+// 相对路径，两者都可能有空格。
+const MEMORY_COMMA_ONLY_FLAGS = new Set(['--keywords', '--replaces']);
+/** 逗号分隔项：去空、去首尾空白，重新用逗号连接。 */
+function joinCommaList(value) {
+    return value.split(',').map(item => item.trim()).filter(Boolean).join(',');
+}
+/**
+ * 把列表参数统一成逗号分隔。PowerShell 把未加引号的 `a,b` 当数组，经 npm 的
+ * ec.ps1 用 `$args` 转发给 node 时逗号消失：`a,b` 变成 `a b`，`a, b` 和
+ * `a,b, c` 也变成 `a b` / `a b c`（实测 PS 5.1）。审批侧按命令串解析时看到的
+ * 是 `a,` 和 `b` 两个 token。两边在这里收敛到同一表示，委托哈希才能对上。
+ *
+ * 值以逗号结尾说明逗号数组还没结束：把后续 token 并进同一个值里再拆。值里本来
+ * 带逗号却没有空格的写法（bash 下 `--tags "a, b"`）也会被拆成两个标签，这是刻
+ * 意取舍——标签都是不含空格的单词，而 ec.ps1 已经把 `a, b` 和 `a,b` 归成了一
+ * 个值，无法再区分。
+ */
+function canonicalizeListFlags(argv, flags) {
+    for (let index = 0; index < argv.length; index++) {
+        const value = argv[index];
+        if (value === '--')
+            break;
+        if (!flags.has(value))
+            continue;
+        if (argv[index + 1] === undefined || argv[index + 1].startsWith('--'))
+            continue;
+        // `--tags a, b` 在 PowerShell 里是同一个值，审批侧却解析成 `a,` 加 `b`，
+        // 这里按逗号是否收尾把后续 token 续接回来
+        let end = index + 1;
+        while (argv[end].endsWith(',') && argv[end + 1] !== undefined
+            && !argv[end + 1].startsWith('--')) {
+            end++;
+        }
+        argv[index + 1] = argv.slice(index + 1, end + 1)
+            .join(' ')
+            .split(/[,\s]+/u)
+            .filter(Boolean)
+            .join(',');
+        if (end > index + 1)
+            argv.splice(index + 2, end - index - 1);
+        index++;
+    }
+}
+/**
+ * 只按逗号归一化，不动值里的空格。
+ *
+ * 与 canonicalizeListFlags 的区别：`--keywords 'a b'` 是一个含空格的关键词，
+ * 不能被拆成两个。所以只在值本身带逗号时整理（顺带去掉逗号周围的空白），
+ * `--keywords a,b` 这种未加引号的写法在 PowerShell 下会先被折成 `a b`，此处
+ * 认不出来——那属于被拒绝的写法，靠规范要求单引号避免。
+ */
+function canonicalizeCommaOnlyFlags(argv, flags) {
+    for (let index = 0; index < argv.length; index++) {
+        const value = argv[index];
+        if (value === '--')
+            break;
+        if (!flags.has(value))
+            continue;
+        const next = argv[index + 1];
+        if (next === undefined || next.startsWith('--') || !next.includes(','))
+            continue;
+        argv[index + 1] = joinCommaList(next);
+        index++;
+    }
+}
 function canonicalizeHandoffText(argv) {
     const action = argv[2];
     if (action !== 'return' && action !== 'recover-return')
@@ -739,7 +810,8 @@ function canonicalizeHandoffText(argv) {
  * Convert an EC invocation to the one argv representation shared by approval,
  * delegation hashing, IPC, and command execution. Shell syntax is already
  * resolved before this function is called; this function only normalizes the
- * EC entrypoint and applies the command-specific inline text contract.
+ * EC entrypoint, applies the command-specific inline text contract, and joins
+ * memory list flags with commas.
  */
 export function canonicalizeEvolcoreCommandArgv(argv) {
     const canonical = normalizeEvolcoreCommandArgv(argv);
@@ -759,11 +831,13 @@ export function canonicalizeEvolcoreCommandArgv(argv) {
     else if (command === 'msg' && subcommand === 'send') {
         decodeInlineFlags(result, INLINE_TEXT_FLAGS.msgSend);
         decodePositionalText(result, 5, MESSAGE_POSITIONAL_FLAGS);
+        canonicalizeListFlags(result, SEND_LIST_FLAGS);
     }
     else if (command === 'group') {
         if (subcommand === 'send') {
             decodeInlineFlags(result, INLINE_TEXT_FLAGS.groupSend);
             decodePositionalText(result, 5, MESSAGE_POSITIONAL_FLAGS);
+            canonicalizeListFlags(result, SEND_LIST_FLAGS);
         }
         else if (subcommand === 'create')
             decodeInlineFlags(result, INLINE_TEXT_FLAGS.groupCreate);
@@ -785,6 +859,13 @@ export function canonicalizeEvolcoreCommandArgv(argv) {
     else if (command === 'handoff') {
         canonicalizeHandoffText(result);
     }
+    else if (command === 'memory') {
+        canonicalizeListFlags(result, MEMORY_LIST_FLAGS);
+        canonicalizeCommaOnlyFlags(result, MEMORY_COMMA_ONLY_FLAGS);
+    }
+    else if (command === 'fs' && subcommand === 'chmod') {
+        canonicalizeListFlags(result, FS_LIST_FLAGS);
+    }
     return result;
 }
 const POWERSHELL_CREDENTIAL_ENV_RE = /^(EVOLCORE_CODEX_SESSION_TOKEN|EVOLCORE_DELEGATION_TOKEN)$/i;
@@ -1496,6 +1577,8 @@ export function parseLiteralShellCommand(command, options = {}) {
     let token = '';
     let tokenStarted = false;
     let quote = null;
+    // EC 命令的自由文本有额外的写法约束（见双引号分支的反引号/$ 转义处理）。
+    const isEcCommand = hasEcCommandPrefix(input);
     const finishToken = () => {
         if (!tokenStarted)
             return;
@@ -1527,6 +1610,12 @@ export function parseLiteralShellCommand(command, options = {}) {
                 return parseFailure(issue, input, index, argv.length, 'posix');
             if (char === '\\') {
                 const next = input[++index];
+                // EC 自由文本只接受单引号一种写法。双引号里用反斜杠转义 ` 或 $ 虽然
+                // 能得到字面量，但同一条规则下要记两套写法，所以对 ec 命令显式拒绝，
+                // 把正文一律导向单引号。非 ec 命令保持原行为。
+                if (isEcCommand && (next === '`' || next === '$')) {
+                    return parseFailure('unsupported-escape', input, index, argv.length, 'posix');
+                }
                 token += ['"', '\\', '$', '`'].includes(next) ? next : `\\${next}`;
                 continue;
             }
@@ -1715,7 +1804,7 @@ function normalizeApplyPatchPath(value) {
         return undefined;
     return normalized;
 }
-function parseApplyPatchDocument(source) {
+export function parseApplyPatchDocument(source) {
     const lines = source.replace(/\r\n?/gu, '\n').split('\n');
     while (lines.at(-1) === '')
         lines.pop();
@@ -2762,7 +2851,8 @@ function findSingleFileOption(argv, startIndex) {
 const PROACTIVE_SEND_VALUE_FLAGS = new Set([
     '--format', '--app', '--file', '--text-from-file', '--link', '--payload',
     '--title', '--description', '--text', '--transcript', '--as',
-    '--content-type', '--mention', '--aun-path', '--thread', '--return', '--handoff-context',
+    '--content-type', '--mention', '--aun-path', '--thread', '--handoff-context',
+    '--check-every', '--trigger-prompt',
 ]);
 const PROACTIVE_SEND_BOOLEAN_FLAGS = new Set([
     '--encrypt', '--no-encrypt', '--mention-all',
@@ -2850,6 +2940,13 @@ function hasExecutableProactiveSendPayload(argv, scope) {
         if (PROACTIVE_SEND_BOOLEAN_FLAGS.has(value))
             continue;
         if (!PROACTIVE_SEND_VALUE_FLAGS.has(value)) {
+            // 未知 `--flag`（可能带值）不是正文；只有裸 token 计入正文。
+            if (value.startsWith('--')) {
+                const next = argv[index + 1];
+                if (next !== undefined && !next.startsWith('--'))
+                    index++;
+                continue;
+            }
             positionals.push(value);
             continue;
         }
@@ -2860,8 +2957,6 @@ function hasExecutableProactiveSendPayload(argv, scope) {
             return false;
         if (value === '--app' || value === '--aun-path')
             return false;
-        if (value === '--return' && operand !== 'none' && operand !== 'required')
-            return false;
         if (value === '--format' && operand !== 'json')
             return false;
         if (value === '--link') {
@@ -2970,8 +3065,12 @@ export function isExactEvolcoreSendCommandForSession(toolName, input, channelId,
         && !!argv
         && hasExecutableProactiveSendPayload(argv, expectedScope);
 }
-/** Diagnostic only: this never broadens the exact-send authorization check. */
-export function describeProactiveSendCommandFailure(toolName, input) {
+/**
+ * 逐项诊断 proactive 发送命令被拒的具体原因。只读 argv 与（可选的）会话参数，
+ * 不扩大任何授权面：授权判定仍在 isExactEvolcoreSendCommandForSession /
+ * isThreadRoutedEvolcoreSendCommand 中。
+ */
+export function describeProactiveSendCommandFailure(toolName, input, session) {
     if (!['Bash', 'Shell', 'exec'].includes(toolName) || !input || typeof input !== 'object')
         return undefined;
     const commandText = [input.command, input.input, ...(Array.isArray(input.commandArgv) ? input.commandArgv : [])]
@@ -2985,5 +3084,114 @@ export function describeProactiveSendCommandFailure(toolName, input) {
         return `当前汇报命令未通过规范解析（${result.issue}，${result.dialect}，位置 ${result.offset}）；`
             + '请检查引号和转义，并将发送作为一条独立命令。';
     }
-    return '当前汇报命令不符合当前会话的发送要求；请核对发送者、私聊或群目标，以及正文和参数。';
+    // 正文里只是提到 "ec msg send" 的其它命令（如 ec memory note "..."）不是发送调用。
+    const argv = result.argv;
+    if (argv[0] !== 'ec' || (argv[1] !== 'msg' && argv[1] !== 'group') || argv[2] !== 'send')
+        return undefined;
+    // --help / -h 是只读的参数查询，不是发送调用，更不该计入 proactive 违规计数。
+    if (argv.includes('--help') || argv.includes('-h'))
+        return undefined;
+    const scope = argv[1];
+    const prefix = '发送命令被拒：';
+    const expectedForm = `ec ${scope} send ${session?.selfAid ?? '<selfAid>'} `
+        + (scope === 'group' ? `${session?.channelId ?? '<群AID>'}` : `${session?.channelId ?? '<对端AID>'}`)
+        + ' "<正文>"';
+    // 带 --thread 的发送走话题路由校验，允许省略 from/to；走到这里说明话题本身没解析通过。
+    if (sendOptionValue(argv, '--thread')) {
+        return `${prefix}带 --thread 的跨话题发送未通过校验——话题必须已存在于本端索引，from（若给出）必须是本人，`
+            + `to（若给出）必须是该话题对端，且需携带 --check-every。可用 ec thread list <对方AID> 确认话题。`;
+    }
+    // 私聊/群聊用错了 scope。
+    if (session?.chatType && (session.chatType === 'group') !== (scope === 'group')) {
+        return session.chatType === 'group'
+            ? `${prefix}当前是群聊会话，公开回复必须用 ec group send ${session.selfAid ?? '<selfAid>'} `
+                + `${session.channelId ?? '<群AID>'} "<正文>"；ec msg send 仅用于已获授权时私下联系本条消息发送者。`
+            : `${prefix}当前是私聊会话，回复用 ${expectedForm}；群回复才用 ec group send。`;
+    }
+    const from = argv[3];
+    const to = argv[4];
+    const fullFormHint = `${prefix}缺少发送者与目标。完整形式为 ${expectedForm}；`
+        + `省略 from/to 仅在带 --thread 的跨话题发送中允许，普通回复也可用 ec ctl send '<正文>' 继承当前会话。`;
+    if (!from || from.startsWith('--')) {
+        return fullFormHint;
+    }
+    if (!to || to.startsWith('--')) {
+        return looksLikeAid(from)
+            ? fullFormHint
+            : `${prefix}缺少发送者与目标（"${from}" 是正文而非 AID）。完整形式为 ${expectedForm}；`
+                + `省略 from/to 仅在带 --thread 的跨话题发送中允许，普通回复也可用 ec ctl send '<正文>' 继承当前会话。`;
+    }
+    if (!looksLikeAid(from) || !looksLikeAid(to)) {
+        return `${prefix}发送者/目标不是合法 AID（收到 from="${from}" to="${to}"）。完整形式为 ${expectedForm}。`;
+    }
+    if (session?.selfAid && from !== session.selfAid) {
+        return `${prefix}发送者必须是本会话身份 ${session.selfAid}，命令里写的是 ${from}。完整形式为 ${expectedForm}。`;
+    }
+    if (session?.channelId && to !== session.channelId) {
+        return `${prefix}目标必须是当前会话${scope === 'group' ? '群' : '对端'} ${session.channelId}，命令里写的是 ${to}；`
+            + `要联系其他对象请走 --thread 跨话题发送（ec thread list <对方AID> 选中话题后加 --check-every）。`;
+    }
+    return `${prefix}发送者与目标正确，但正文或参数无效——正文不能为空；--file/--text-from-file 属于文件发送，`
+        + '不在普通回复放行范围；--link 的值必须是 http(s) URL；--payload 的值必须是 JSON 对象。';
+}
+/** 与 CLI `isValidAid` 同一规则；parser 不依赖 AID 模块，避免引入身份存储副作用。 */
+function looksLikeAid(value) {
+    if (!value)
+        return false;
+    const labels = value.split('.');
+    return labels.length >= 3 && labels.every(label => /^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/.test(label));
+}
+function sendOptionValue(argv, flag) {
+    for (let index = 3; index < argv.length; index++) {
+        if (argv[index] === '--')
+            return undefined;
+        if (argv[index] === flag) {
+            const value = argv[index + 1];
+            return value && !value.startsWith('--') ? value : undefined;
+        }
+    }
+    return undefined;
+}
+/**
+ * 带 `--thread` 的跨话题发送：目标由话题推断，不受「只能发给当前对端/群」限制。
+ *
+ * 支持完整形式 `ec msg|group send <self> <target> ... --thread <id>`，以及私聊
+ * 简化形式 `ec msg send "<text>" --thread <id>`（目标取话题 peer）。
+ * `resolveThread` 必须校验话题存在于本端索引、scope 与话题类型一致，且给出
+ * target 时与话题 peer 相同；这里只做语法与发送者校验。
+ */
+export function isThreadRoutedEvolcoreSendCommand(toolName, input, selfAid, resolveThread) {
+    if (!selfAid || !['Bash', 'Shell', 'exec'].includes(toolName) || !input || typeof input !== 'object')
+        return false;
+    const result = parseProactiveToolCommand(toolName, input);
+    if (!result?.ok)
+        return false;
+    const argv = result.argv;
+    if (argv[0] !== 'ec' || (argv[1] !== 'msg' && argv[1] !== 'group') || argv[2] !== 'send')
+        return false;
+    const scope = argv[1];
+    const threadId = sendOptionValue(argv, '--thread');
+    if (!threadId)
+        return false;
+    const self = selfAid.replace(/^@/, '');
+    const hasFrom = looksLikeAid(argv[3]);
+    const hasTo = hasFrom && looksLikeAid(argv[4]);
+    let normalized;
+    let target;
+    if (hasFrom && hasTo) {
+        if (argv[3] !== self)
+            return false;
+        target = argv[4];
+        normalized = argv;
+    }
+    else if (!hasFrom && scope === 'msg') {
+        // 与 CLI 托管推断一致：from/to 均省略时由 selfAid 与话题 peer 补齐。
+        normalized = ['ec', scope, 'send', self, '<thread-peer>', ...argv.slice(3)];
+    }
+    else {
+        return false;
+    }
+    if (!hasExecutableProactiveSendPayload(normalized, scope))
+        return false;
+    return resolveThread(scope, threadId, target);
 }

package/dist/core/permission/protected-paths.js

@@ -938,7 +938,11 @@ export function lClassGrantIncludesProtectedPath(value, options = {}) {
         // A grant covering an Agent root also covers its L-class configuration.
         if (segments.length <= 2)
             return true;
-        return ['config.json', 'contact.json', 'contact-operations.jsonl', 'relations', 'roles', 'triggers']
+        // relations/ 下的 L 类只有 relations/<peer>/config.json：只有范围是 relations/ 或
+        // relations/<peer> 本身时才覆盖它，更深的路径（如 relations/<peer>/memory/…）不会。
+        if (segments[2] === 'relations')
+            return segments.length <= 4;
+        return ['config.json', 'contact.json', 'contact-operations.jsonl', 'roles', 'triggers']
             .includes(segments[2]);
     }
     return false;