evolcore 0.0.31 → 0.0.33

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. */
@@ -2762,7 +2762,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 +2851,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 +2868,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 +2976,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 +2995,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/sandbox-runtime.js

@@ -563,6 +563,14 @@ function appendLClassReadOnlyBinds(args, root, options = {}) {
         args.push('--ro-bind', target.path, target.path);
     }
 }
+function appendLClassMasks(args, root, options = {}) {
+    for (const target of getExistingLClassReadOnlyTargets(root, options)) {
+        if (target.kind === 'directory')
+            pushMaskedDirectory(args, target.path);
+        else
+            pushMaskedFile(args, target.path);
+    }
+}
 export function ensureCodexManagedMountpoint(systemConfigDirectory = '/etc/codex', effectiveUid = typeof process.getuid === 'function' ? process.getuid() : undefined) {
     let systemConfigStat;
     try {
@@ -691,7 +699,12 @@ export function buildBubblewrapCommand(executable, executableArgs, options) {
                 pushMaskedFile(args, resolved);
         }
     }
-    appendLClassReadOnlyBinds(args, root, options);
+    if (options.denyLClassRead) {
+        appendLClassMasks(args, root, options);
+    }
+    else {
+        appendLClassReadOnlyBinds(args, root, options);
+    }
     appendHClassMasks(args, root, true, options);
     if (options.exposeDaemonIpc !== false)
         appendDaemonIpcSocket(args, root);