evolcore 0.0.29 → 0.0.30

package/dist/utils/evolcore-version.js

@@ -1,6 +1,7 @@
 import crypto from 'node:crypto';
 import fs from 'fs';
 import path from 'path';
+import { fileURLToPath } from 'url';
 import { getPackageRoot } from '../paths.js';
 let cachedVersion;
 let cachedFlavor;
@@ -20,6 +21,27 @@ export function readInstalledEvolcoreVersion() {
     cachedVersion = version;
     return version;
 }
+export function readFastaunVersion() {
+    try {
+        const url = import.meta.resolve?.('@agentunion/fastaun');
+        if (!url)
+            return 'unknown';
+        let dir = path.dirname(fileURLToPath(url));
+        while (dir !== path.dirname(dir)) {
+            const packagePath = path.join(dir, 'package.json');
+            if (fs.existsSync(packagePath)) {
+                const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
+                if (packageJson.name === '@agentunion/fastaun')
+                    return packageJson.version || 'unknown';
+            }
+            dir = path.dirname(dir);
+        }
+        return 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
 /**
  * 区分源码仓库运行与全局安装包。`package.json` 的 `files` 白名单不含 `src/`，
  * 所以 `src/index.ts` 的存在性可以稳定区分两者：同一个版本号在 dev 下跑的是
@@ -148,3 +170,55 @@ export function readBuildIdentity(distDir, version) {
         ...(version ? { version } : {}),
     };
 }
+export function reportEvolcoreStartup(entryUrl, report) {
+    const packageRoot = getPackageRoot();
+    const runtimeEntry = fileURLToPath(entryUrl);
+    const diskDistDir = path.join(packageRoot, 'dist');
+    const runtimeIsDist = path.resolve(path.dirname(runtimeEntry)) === path.resolve(diskDistDir);
+    const runtimeBuildIdentity = readBuildIdentity(runtimeIsDist ? path.dirname(runtimeEntry) : diskDistDir, readInstalledEvolcoreVersion());
+    if (!runtimeIsDist)
+        runtimeBuildIdentity.id = null;
+    const isLinked = fs.existsSync(path.join(packageRoot, '.git'));
+    const directoryType = runtimeIsDist ? (isLinked ? '开发仓/dist' : '安装路径/dist') : '源码(tsx)';
+    const scanDir = runtimeIsDist ? path.join(packageRoot, 'dist') : path.join(packageRoot, 'src');
+    let latestMtime = 0;
+    const scanRecursive = (directory) => {
+        try {
+            for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+                if (entry.name === 'node_modules')
+                    continue;
+                const full = path.join(directory, entry.name);
+                if (entry.isDirectory()) {
+                    scanRecursive(full);
+                    continue;
+                }
+                if (entry.name.endsWith('.js') || entry.name.endsWith('.ts')) {
+                    const modifiedAt = fs.statSync(full).mtimeMs;
+                    if (modifiedAt > latestMtime)
+                        latestMtime = modifiedAt;
+                }
+            }
+        }
+        catch { }
+    };
+    scanRecursive(scanDir);
+    let version = '?';
+    try {
+        version = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf-8')).version;
+    }
+    catch { }
+    const formatTime = (milliseconds) => {
+        const date = new Date(milliseconds);
+        return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())} ${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}`;
+    };
+    console.error(`[EvolCore] EvolCore v${version}`);
+    console.error(`[EvolCore] 执行类型: ${directoryType}`);
+    console.error(`[EvolCore] 包路径:   ${packageRoot}`);
+    console.error(`[EvolCore] 代码时间: ${latestMtime ? formatTime(latestMtime) : '?'}`);
+    console.error('[EvolCore] ✓ Version info printed');
+    const diskBuildId = computeBuildId(diskDistDir);
+    console.error(`[EvolCore] 运行 build ID: ${runtimeIsDist ? (runtimeBuildIdentity.id ?? '?') : 'source'}`);
+    console.error(`[EvolCore] 磁盘 dist build ID: ${diskBuildId ?? '?'}`);
+    report(`[Build] runtimeMode=${runtimeIsDist ? 'dist' : 'source'} runtimeBuildId=${runtimeBuildIdentity.id ?? 'source'} diskDistBuildId=${diskBuildId ?? 'unknown'} match=${runtimeIsDist && runtimeBuildIdentity.id !== null && runtimeBuildIdentity.id === diskBuildId}`);
+    return { runtimeIsDist, runtimeBuildIdentity, diskDistDir };
+}

package/dist/utils/logger.js

@@ -12,6 +12,22 @@ const config = {
 };
 let writers = null;
 fs.mkdirSync(resolvePaths().logs, { recursive: true });
+export function installChannelSdkConsoleFilter() {
+    const originalLog = console.log;
+    const originalInfo = console.info;
+    const filter = (...args) => {
+        const firstArg = String(args[0] || '');
+        return firstArg.includes('[info]') || firstArg.includes('[ws]');
+    };
+    console.log = (...args) => {
+        if (!filter(...args))
+            originalLog(...args);
+    };
+    console.info = (...args) => {
+        if (!filter(...args))
+            originalInfo(...args);
+    };
+}
 function closeWriters(current) {
     current.main.close();
     current.message?.close();

package/kits/docs/evolcore/INDEX.md

@@ -42,7 +42,7 @@ Windows 上 Codex 托管任务出现 `helper_sandbox_lock_failed`、`SetNamedSec
 | `ec storage` | 文件存储底层调试入口 | storage 调试/旧命令/底层上传下载 | 任意有渠道场景 | `storage.md` |
 | `ec agent` | EvolAgent 生命周期 | 创建/启停/热重载/改配置 | 管理员（owner/admin） | `agent.md`；完整创建与 Bootstrap 见 `agent-create.md` |
 | `ec contact` | Contact Book 与访问控制 | 申请添加、拉黑/解除拉黑、查拉黑 | Agent 当前私聊可申请添加；管理写操作按角色限制 | `contact.md` |
-| `ec rpc` | 底层 AUN RPC（逃生通道） | 直接调协议方法 | 高级/兜底 | `rpc.md` |
+| `ec rpc` | 底层 AUN RPC（逃生通道） | 直接调协议方法 | 仅宿主终端；托管会话仅可查看帮助 | `rpc.md` |
 | `ec menu-client` | 远程 Daemon Menu 请求 | 远程诊断/远程 daemon 操作/daemon 日志/监控/原始配置/跨主机 | 运维主机或具备 `ec.menu.request` 权限的托管 Agent | `menu-client.md` |
 
 ## 会话自管理类（不连 AUN，操作当前会话）

package/kits/docs/evolcore/aid.md

@@ -6,16 +6,23 @@
 
 本页列出独立终端中 `ec aid` 的完整 CLI 能力。在 EvolCore 托管 Agent 会话中，为防止会话枚举、创建、删除或切换本地身份，只允许以下精确命令：
 
+帮助查询不受 AID 操作范围限制：`ec aid`、`ec aid --help`、`ec aid help` 以及各子命令的 `--help` / `-h` 只显示用法，不执行身份操作。实际操作仍按下列范围鉴权。
+
 ```bash
 ec aid show <当前 self AID> [--format json]
 ec aid lookup <任意合法 AID> [--format json]
 ec aid agentmd get <任意合法 AID> [--format json]
 # 仅 request / bypass
 ec aid agentmd put <当前 self AID> [--format json]
+ec aid agentmd set <当前 self AID> <name|type|description|version|tags> <value> [--format json]
 ec aid avatar <当前 self AID> (--file <path> | --url <https-url>) [--format json]
 ```
 
-仅允许不带选项的基本形式，或在末尾附加一组完整的 `--format json`；不能使用 `--aun-path`、未知选项、管道、重定向或其它命令。所有 `allowAccess=true` 的已认证角色（包括 visitor、member、admin、owner 及自定义角色）均开放 `lookup` 和 `agentmd get`，目标可以是任意合法 AID。`show` 只允许当前 self AID：owner/admin 返回完整本地身份诊断，visitor/member 及其它非管理角色返回不含私钥存在性、密钥匹配和签名能力的脱敏结果。三个查询可在所有 `permissionMode` 执行。`agentmd put` 和 `avatar` 会发布远端名片，属于写操作，仅允许针对当前 self AID 的 `request`、`bypass`，`readonly`、`auto` 和未知模式均拒绝。头像支持 PNG、JPEG、WebP，大小上限 500KB，分辨率 128–2048 像素，宽高比 0.8–1.25；`--url` 仅支持 HTTPS，下载由 daemon 执行并做 SSRF/重定向校验。成功 JSON 返回 `sha256`、MIME 和尺寸元数据。`lookup` 探测指定公开 AID；`get` 下载并验签指定公开名片，同时刷新本地 AID 缓存。`list`、其它 AID 的 `show/agentmd put/avatar` 以及 `new/delete` 均拒绝。独立终端不受此托管会话限制。
+`set` 的 value 是单个 CLI 参数；`tags` 必须传 JSON 字符串数组，例如 `'["coding","tools","aun"]'`。set 仅更改 YAML frontmatter 对应字段，保留正文，再签名发布。`name`、`type`、`description`、`version` 与 `tags` 会按 agent.md schema 校验。
+
+仅允许不带选项的基本形式，或在末尾附加一组完整的 `--format json`；不能使用 `--aun-path`、未知选项、管道、重定向或其它命令。所有 `allowAccess=true` 的已认证角色（包括 visitor、member、admin、owner 及自定义角色）均开放 `lookup` 和 `agentmd get`，目标可以是任意合法 AID。`show` 只允许当前 self AID：owner/admin 返回完整本地身份诊断，visitor/member 及其它非管理角色返回不含私钥存在性、密钥匹配和签名能力的脱敏结果。三个查询可在所有 `permissionMode` 执行。`agentmd put`、`agentmd set` 和 `avatar` 会发布远端名片，属于写操作，仅允许针对当前 self AID 的 `request`、`bypass`，`readonly`、`auto` 和未知模式均拒绝。头像支持 PNG、JPEG、WebP，大小上限 500KB，分辨率 128–2048 像素，宽高比 0.8–1.25；`--url` 仅支持 HTTPS，下载由 daemon 执行并做 SSRF/重定向校验。成功 JSON 返回 `sha256`、MIME 和尺寸元数据。`lookup` 探测指定公开 AID；`get` 下载并验签指定公开名片，同时刷新本地 AID 缓存。`list`、其它 AID 的 `show/agentmd put/set/avatar` 以及 `new/delete` 均拒绝。独立终端不受此托管会话限制。
+
+`agentmd get --format json` 返回 `verification`、来源 `source`（`remote` / `local-cache`）、内容 SHA-256 和 `localState`；有远端版本响应头时还返回 ETag / Last-Modified。`agentmd put/set --format json` 返回发布后版本信息、是否执行了版本预检，以及 `atomicVersionCheck: false`。当前 fastaun upload API 不支持条件 PUT / If-Match，因此版本预检和进程内锁**不是原子远端 CAS**：多客户端并发更新仍可能在预检后覆盖；在网关或 SDK 支持条件写入前，不应将其视为完整并发锁。
 
 ## 更换头像
 
@@ -43,6 +50,7 @@ ec aid lookup <aid>
 # agent.md 名片：签名上传 / 下载验签
 ec aid agentmd put <aid>
 ec aid agentmd get <aid>
+ec aid agentmd set <aid> <name|type|description|version|tags> <value>
 ec aid avatar <aid> (--file <path> | --url <https-url>)
 
 # 删除指定本地 AID（无网络注销）

package/kits/docs/evolcore/model.md

@@ -38,8 +38,9 @@ ec model check [--self <aid>]
 
 生效优先级为关系、角色、agent、defaults。`--peer` 可使用 `channelType#channelId`；裸 AID 按 `aun#<aid>` 处理。
 
-在 EvolCore 托管会话中，省略 `--self`、`--peer`、`--role` 时，`list/current/use/effort/reset`
-会通过 `ec ctl` 作用于当前会话；显式 selector 仍按上表访问持久化作用域。本机终端不具备该隐式当前会话语义。
+在 EvolCore 托管会话中，所有 `ec model` 子命令都通过 daemon 的 `ec ctl` 路径作用于已认证的当前会话，不能指定 `--self`、`--peer` 或 `--role`；上表的显式作用域仅适用于宿主终端。需要读取或修改持久化模型配置时，使用 `ec config`，由 daemon 按实际角色和目标范围鉴权。本机终端不具备隐式当前会话语义。
+
+帮助查询不选择目标或执行操作，`ec model list --self <aid> --help` 等形式仍可查看帮助。
 
 ## 输出与权限
 

package/kits/docs/evolcore/rpc.md

@@ -4,6 +4,10 @@
 
 > 常规消息收发用 `ec msg` / `ec group`，文件用 `ec storage`。`ec rpc` 是这些命令未覆盖到协议方法时的低层入口。
 
+## 运行边界
+
+实际 RPC 调用仅供宿主终端使用；EvolCore 托管 Agent 会话只能查看 `ec rpc --help`，不能执行协议调用。此入口会直接使用指定本地 AID 建立 SDK 连接，没有托管会话的 delegated sender 和逐操作 daemon 鉴权，因此不能用于绕过 `ec msg`、`ec group` 或 `ec fs` 的权限限制。
+
 ## 用法
 
 ```bash

package/kits/docs/evolcore/trigger.md

@@ -4,6 +4,20 @@
 
 > `ec trigger` 通过 daemon IPC 直接操作 TriggerRuntimeScheduler。agent 会话内省略 `--agent` 时，CLI 使用当前任务上下文里的 agent AID；只有跨身份操作或脱离 agent 会话执行时才需要显式传 `--agent <aid>`。
 
+## 运行边界
+
+托管 Agent 的实际 owner 可使用 `--file`、`--prompt-file`、`--script-path` 和 `--script-file`。CLI 必须先通过 daemon 校验当前 delegation、真实关系角色和有效权限模式，再读取当前项目或本会话 `$TMPDIR` 内的文件；readonly 任务不能创建或修改 Trigger，环境变量里的 owner 声明不能代替授权。普通管理角色仍可按原权限使用内联 `--prompt`。
+
+文件输入限制为 4 MiB，拒绝符号链接、junction、硬链接、路径逃逸、其他会话临时目录、密钥及其他 Agent 私有数据。普通定义导入必须属于当前 Agent；脚本只上传 `execution.script.path` 指定的单个文件，不允许覆盖 `trigger.json`、`active.json` 等管理状态。绝对 `--script-path` 会上传脚本内容并保存 Agent 内相对路径，不保留宿主绝对路径。`--help` / `-h` 在鉴权和文件读取前返回。
+
+普通脚本 Trigger 按每次执行重新核验的 Agent 授权运行，`bypass` 不等于宿主权限：项目按有效模式只读或可写，脚本使用只读快照，只有当前 run 的临时工作目录可写，不继承 daemon 凭据或 IPC 入口，网络禁用。脚本快照位置不同于持久化 Trigger 目录；需要项目资源时按工作目录定位，不能依赖 Trigger 状态文件或其他脚本附件。Node `.js` 保留原 package 的模块类型。
+
+- Linux：需要可用的 `bubblewrap`，使用独立根文件系统及进程/网络命名空间，仅绑定项目、最小系统运行时和当前 run。
+- Windows：需要支持受限读取策略的原生 Codex CLI，以及宿主已准备好的 elevated sandbox。每次启动前先用同一个临时 canary 验证“显式授权可读、撤回授权后拒绝读取”和当前 run 可写；只有权限拒绝才算通过，文件不存在、探针超时或取消均失败关闭。旧初始化、不支持的运行时或无法证明读取隔离时返回 `SCRIPT_SANDBOX_UNAVAILABLE`，不会启动用户脚本；托管任务不会自动提权、初始化沙箱或降级为宿主执行。
+- 其他平台：当前普通脚本执行失败关闭，不提供未隔离的回退。
+
+有效批准的 `fullaccess` 和 daemon 自有 Trigger 仍走宿主执行路径。`fullaccess` 每次检查批准者是否仍是 DaemonOwner，不依赖普通创建者的当前关系角色；daemon 自有任务检查服务授权。普通 Agent Trigger 每次执行及重试都检查来源主体在该 Agent 上的当前角色和权限上限，撤销授权后不再启动脚本。
+
 ## 什么时候用
 
 - 用户要求“稍后/每天/每小时/定时/周期性”执行任务
@@ -244,7 +258,7 @@ ec trigger rm <triggerId>       # delete 的兼容别名
 
 `update` 是 patch 语义，只提交需要修改的字段；未指定字段（包括长 prompt）保持不变。`--prompt-file <path>` 只更新非 script trigger 的 prompt，不接受完整 definition。已有 script trigger 使用 `--script-file <path>` 原地替换脚本内容；脚本路径、runtime、args 和调度配置保持不变：
 
-`--script-file` 只能通过本机受控 CLI 读取文件并提交给 daemon；脚本 trigger 属于 daemon-owner 控制面，managed Agent task 不能直接读取本地脚本文件。Agent 级 `fullaccess.enabled` 不会自动升级 Trigger，Trigger 仍按自身 execution.permissionMode 规则执行；`permissionMode=fullaccess` 由 daemon-owner 批准链控制。
+`--script-file` 通过受控 CLI 读取文件并提交给 daemon；托管任务的实际 Agent owner 在授权范围内也可替换自己的普通脚本。读取前和提交时分别校验授权，脚本原子落盘并重新验证路径。Agent 级 `fullaccess.enabled` 或创建会话的 fullaccess 身份不会自动升级 Trigger；宿主执行仍由 Trigger 自身 `execution.permissionMode=fullaccess` 和当前有效的 DaemonOwner 批准链控制。
 
 ```bash
 ec trigger update <triggerId> --cron '0 10 * * *'

package/kits/schemas/relation-config.schema.9.json

@@ -72,7 +72,7 @@
       "x-merge": "scalar",
       "description": "群聊 auto 注意力分类的静默等待窗口，单位为毫秒；默认 3000"
     },
-    "sessionIdleSeconds": {
+    "sessionIdleSec": {
       "type": "number",
       "x-merge": "scalar",
       "description": "会话闲置周期，单位为秒；缺省或小于等于 0 关闭，正值小于 30 秒按 30 秒处理"

package/kits/templates/system-fragments/commands.md

@@ -19,7 +19,6 @@ ec task     恢复暂停或异常中断的本 Agent 会话任务（resume <sessi
 ec aid     身份/证书/名片/换头像（avatar --file/--url）/探测对端  $KITS_DOCS/evolcore/aid.md
 ec fs      AUN 文件系统统一入口（ls/stat/cat/cp/mv/rm/mkdir/ln/chmod/setfacl/getfacl/token/find/df/mount/approve/reject/umount；个人/群空间同一入口；没有 ec group fs） $KITS_DOCS/evolcore/fs.md
 ec storage 文件上传/下载/配额（底层调试入口，日常优先 ec fs） $KITS_DOCS/evolcore/storage.md
-ec rpc     底层 AUN RPC 逃生通道                      $KITS_DOCS/evolcore/rpc.md
 {{?peerId}}
 ec msg     私聊收发消息（回复/拉取/撤回）            $KITS_DOCS/evolcore/msg.md
 {{/}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evolcore",
-  "version": "0.0.29",
+  "version": "0.0.30",
   "description": "AI Agent gateway connecting Claude, Codex, Gemini, and the bundled ecagent runner to messaging channels with multi-project session management",
   "type": "module",
   "main": "dist/index.js",

package/dist/core/memory/launch-consolidation.js

@@ -1,395 +0,0 @@
-/**
- * launch-consolidation.ts — 拉起一次整理会话
- *
- * 两个入口共用这一处实现：
- *   - ipc.ts：手动 `ec memory consolidate --mode X`
- *   - index.ts：定时检查（五类候选）、compress / session-new 自动触发
- *
- * 流程：序列化上下文文件 → 写一次性触发器 → 交给 TriggerDefinitionManager。
- * `execution.memoryMode` 会经 session.metadata 透传到渲染层与 ipc 的权限校验。
- */
-import fs from 'fs';
-import path from 'path';
-import { resolveRoot } from '../../paths.js';
-import { serializeConsolidationContext } from './consolidation-context.js';
-import { normalizeTriggerDefinition } from '../../trigger/validation.js';
-import { formatChannelKey } from '../channel-loader.js';
-import { formatPeerKey } from '../relation/peer-identity.js';
-import { logger } from '../../utils/logger.js';
-/**
- * 清理当前 agent 的旧整理批次。
- * 启动新整理时调用，保留最新的一个会话历史用于查看和调试。
- */
-function cleanupPreviousConsolidationBatches(selfAid) {
-    try {
-        const batchRoot = path.join(resolveRoot(), 'memory', 'consolidation-batches');
-        if (!fs.existsSync(batchRoot))
-            return;
-        // 匹配格式：YYYYMMDDTHHMMSS-<selfAid>-*
-        const escapedAid = selfAid.replace(/\./g, '\\.');
-        const pattern = new RegExp(`^\\d{8}T\\d{6}-${escapedAid}-`);
-        const entries = fs.readdirSync(batchRoot, { withFileTypes: true })
-            .filter(e => e.isDirectory() && pattern.test(e.name))
-            .map(e => ({ name: e.name, path: path.join(batchRoot, e.name) }))
-            .sort((a, b) => b.name.localeCompare(a.name)); // 最新的在前
-        // 保留最新的一个，删除其他
-        for (let i = 1; i < entries.length; i++) {
-            const dir = entries[i];
-            try {
-                fs.rmSync(dir.path, { recursive: true, force: true });
-                logger.debug(`[Memory] 清理前一次整理批次: ${dir.name}`);
-            }
-            catch (e) {
-                logger.warn(`[Memory] 清理前一次整理批次失败 ${dir.name}: ${e?.message}`);
-            }
-        }
-    }
-    catch (e) {
-        logger.warn(`[Memory] 清理整理批次时出错: ${e?.message}`);
-    }
-}
-export function buildDebugTaskContext(input) {
-    const { session } = input;
-    const meta = (session.metadata ?? {});
-    const sessionType = session.sessionType ?? meta.sessionType ?? 'main';
-    let channel = session.channelType || session.channel;
-    let chatType = session.chatType || 'private';
-    let peerId = meta.peerId;
-    let peerKeyId = chatType === 'group'
-        ? (meta.groupId || session.channelId)
-        : (meta.peerId || session.channelId);
-    let threadId = session.threadId || undefined;
-    if (session.channelId?.startsWith('trigger:') && session.selfAID && input.getTrigger) {
-        const triggerId = session.channelId.slice('trigger:'.length);
-        const origin = input.getTrigger(session.selfAID, triggerId)?.origin;
-        if (origin?.channelType) {
-            channel = origin.channelType;
-            chatType = origin.delivery?.chatType ?? 'private';
-            peerId = origin.peerId;
-            peerKeyId = chatType === 'group' ? origin.channelId : (origin.peerId ?? origin.channelId);
-            threadId = origin.threadId;
-        }
-    }
-    return {
-        sessionId: session.id,
-        baseagent: session.baseagent,
-        channel,
-        channelId: session.channelId,
-        chatType,
-        selfAid: session.selfAID,
-        peerId,
-        peerKey: channel && peerKeyId ? formatPeerKey(channel, peerKeyId) : undefined,
-        peerName: meta.peerName,
-        peerType: meta.peerType,
-        threadId,
-        sessionType,
-        memoryMode: meta.memoryMode,
-        memoryScope: meta.memoryScope,
-        consolidationBatchDir: meta.consolidationBatchDir ?? meta.consolidationLogBase,
-        sessionRuntimeDir: input.sessionRuntimeDir,
-    };
-}
-/**
- * 序列化上下文并直接创建整理会话。
- * 失败抛错，调用方负责决定是否记录诊断或回传错误。
- */
-export async function launchConsolidation(channel, params) {
-    const { taskCtx, mode, triggeredBy, ownerAid } = params;
-    const effectiveCtx = params.peerKeyOverride
-        ? { ...taskCtx, peerKey: params.peerKeyOverride }
-        : taskCtx;
-    const selfAid = effectiveCtx.selfAid;
-    if (!selfAid)
-        throw new Error('无法确定当前 agent AID（selfAid 为空）');
-    // 清理旧的整理批次（保留最新的一个历史）
-    cleanupPreviousConsolidationBatches(selfAid);
-    // notes 模式：pending/ → processing/ 快照迁移（在序列化上下文之前执行，声明认领）
-    let memoryDir;
-    if (mode === 'notes') {
-        memoryDir = effectiveCtx.peerKey
-            ? path.join(resolveRoot(), 'agents', selfAid, 'relations', effectiveCtx.peerKey, 'memory')
-            : path.join(resolveRoot(), 'agents', selfAid, 'personal', 'memory');
-        const pendingDir = path.join(memoryDir, 'pending');
-        const processingDir = path.join(memoryDir, 'processing');
-        if (fs.existsSync(processingDir)) {
-            // 上一批还没收尾（会话仍在跑，或 daemon 中途重启丢了收尾），不覆盖、不合并
-            logger.warn(`[Memory] processing/ 已存在，跳过本次迁移（上一批未收尾）: ${processingDir}`);
-        }
-        else if (fs.existsSync(pendingDir)) {
-            try {
-                const count = fs.readdirSync(pendingDir).filter(f => f.endsWith('.md')).length;
-                fs.renameSync(pendingDir, processingDir);
-                // 立即重建空 pending 目录，供主会话后续写 note
-                fs.mkdirSync(pendingDir, { recursive: true });
-                logger.info(`[Memory] pending → processing 快照完成（${count} 条 note）: ${processingDir}`);
-            }
-            catch (e) {
-                // 迁移失败不阻断整理会话启动，整理会话会发现 processing 目录空并输出 NOOP
-                logger.warn(`[Memory] pending → processing 迁移失败: ${e?.message}`);
-            }
-        }
-    }
-    const ctxFile = serializeConsolidationContext({
-        mode,
-        triggeredBy,
-        taskCtx: effectiveCtx,
-        ownerAid,
-        sessionRuntimeDir: effectiveCtx.sessionRuntimeDir,
-        ownerInvolved: params.ownerInvolved,
-        forgetAfterDays: params.forgetAfterDays,
-        scopeOverride: params.scopeOverride,
-    });
-    const baseagent = effectiveCtx.baseagent ?? 'claude';
-    const now = Date.now();
-    const scopeTag = params.scopeOverride ? `-${params.scopeOverride}` : '';
-    const triggerId = `memory-consolidate-${mode}${scopeTag}-${now.toString(36)}`;
-    // 整理会话的渠道信息（origin）：发起时抓取，供反馈时直接投递到原会话渠道。
-    // 用 channelId/peerId/threadId 三要素——不依赖 evolcore sessionId，renew/`/new` 换会话也不影响送达。
-    const feedbackOrigin = effectiveCtx.channel && effectiveCtx.peerId ? {
-        channelKey: formatChannelKey({ type: effectiveCtx.channel, selfAID: selfAid, name: 'main' }),
-        channelId: effectiveCtx.peerId,
-        channelType: effectiveCtx.channel,
-        peerId: effectiveCtx.peerId,
-        session: effectiveCtx.threadId ? 'thread' : 'main',
-        ...(effectiveCtx.threadId ? { threadId: effectiveCtx.threadId } : {}),
-        delivery: { chatType: effectiveCtx.chatType ?? 'private' },
-    } : undefined;
-    // 构造 TriggerDefinition 形状的数据载体。
-    // daemonChannel.converse() 从 ctx.trigger 读 execution.memoryMode / id / name / agentAid。
-    // 不再调 manager.create()——本函数直接创建会话，不进 trigger 系统的调度/持久化。
-    const triggerDef = normalizeTriggerDefinition({
-        $schema_version: 3.1,
-        id: triggerId,
-        agentAid: selfAid,
-        enabled: true,
-        name: triggerId,
-        description: `记忆整理（mode=${mode}${effectiveCtx.peerKey ? `，peerKey=${effectiveCtx.peerKey}` : ''}）`,
-        createdAt: now,
-        updatedAt: now,
-        source: { type: 'once' },
-        execution: {
-            type: 'trigger_session',
-            prompt: [
-                '你正在执行记忆整理任务。',
-                `本次整理模式：${mode}`,
-                `整理上下文文件路径：${ctxFile.filePath}`,
-                '',
-                '请先读取上述上下文文件，再按照注入的整理规范完成本次整理。',
-            ].join('\n'),
-            baseagent,
-            thread: 'by_run',
-            onError: 'retry',
-            noopSentinel: '[[NOOP]]',
-            memoryMode: mode,
-            ...(params.scopeOverride ? { memoryScope: params.scopeOverride } : {}),
-            // 透传到 session.metadata，供 ipc.ts 写 ops 流水、收尾流程读取
-            consolidationBatchDir: ctxFile.batchDir,
-            ...(ctxFile.chatDir ? { consolidationChatDir: ctxFile.chatDir } : {}),
-            ...(memoryDir ? { consolidationMemoryDir: memoryDir } : {}),
-        },
-        // 不使用 trigger 的 feedback 机制；反馈由收尾流程直接调 adapter.send() 投递
-        feedback: { strategy: 'silent' },
-        ...(feedbackOrigin ? { origin: feedbackOrigin } : {}),
-        reliability: {
-            concurrency: 'forbid',
-            missedPolicy: 'run_once',
-            retry: { maxAttempts: 0, backoffMs: 30_000 },
-        },
-    });
-    // normalizeTriggerDefinition 只保留白名单字段，自定义字段在其后补挂。
-    // 反馈目标（发起时渠道三元组）与触发方式，收尾流程据此投递 / 判断是否反馈。
-    if (feedbackOrigin) {
-        triggerDef.execution.feedbackOrigin = feedbackOrigin;
-    }
-    triggerDef.execution.consolidationTriggeredBy = triggeredBy;
-    // 直接创建整理会话并发送第一条消息——不再经 TriggerRuntimeScheduler。
-    // 用 getOrCreateConversationSession + converse，与旧 trigger_session 执行路径同源（见 daemon.ts）。
-    const projectPath = params.projectPath ?? path.join(resolveRoot(), 'agents', selfAid);
-    const runId = `${triggerId}-run`;
-    const session = await channel.getOrCreateConversationSession(triggerDef, projectPath, baseagent, runId);
-    const prompt = triggerDef.execution.prompt;
-    // 不 await：整理会话在后台跑，收尾由 task:completed/error/interrupted 事件驱动
-    void channel.converse(prompt, {
-        trigger: triggerDef,
-        runId,
-        firedAt: now,
-        projectPath,
-        baseagent,
-        session,
-        causation: undefined,
-    }).catch((e) => {
-        logger.warn(`[Memory] 整理会话执行失败（mode=${mode}，session=${session.id}）: ${e?.message}`);
-    });
-    logger.info(`[Memory] 已拉起整理会话（mode=${mode}，triggeredBy=${triggeredBy}，` +
-        `selfAid=${selfAid}${effectiveCtx.peerKey ? `，peerKey=${effectiveCtx.peerKey}` : ''}，` +
-        `session=${session.id}）`);
-    return {
-        triggerId,
-        contextFile: ctxFile.filePath,
-        contextFilePath: ctxFile.contextFilePath,
-        logFile: ctxFile.contextFilePath,
-        batchDir: ctxFile.batchDir,
-        executionSessionId: session.id,
-    };
-}
-/**
- * 手动 consolidate 用：在超时内轮询等 runner 分配 agentSessionId。
- * 拿到立即返回；超时返回已拿到的部分，不抛错。
- *
- * 会话创建后 executionSessionId 立刻可用，但 agentSessionId 要等 runner 初始化
- * 并开始第一轮才写入 session 记录，所以这里必须轮询等待。
- */
-export async function waitForConsolidationSession(opts) {
-    const executionSessionId = opts.executionSessionId;
-    if (!executionSessionId)
-        return {};
-    const deadline = Date.now() + (opts.timeoutMs ?? 10_000);
-    const interval = opts.intervalMs ?? 250;
-    while (true) {
-        try {
-            const agentSessionId = await opts.readAgentSessionId(executionSessionId);
-            if (agentSessionId)
-                return { executionSessionId, agentSessionId };
-        }
-        catch { /* 会话记录写到一半，下一轮再读 */ }
-        if (Date.now() >= deadline)
-            return { executionSessionId };
-        await new Promise(r => setTimeout(r, interval));
-    }
-}
-/** 把 entry 移进 destDir；重名时加时间戳后缀，不覆盖已有文件。 */
-function moveIntoDir(srcPath, destDir, stamp) {
-    const name = path.basename(srcPath);
-    let dest = path.join(destDir, name);
-    if (fs.existsSync(dest)) {
-        if (fs.statSync(srcPath).isDirectory() && fs.statSync(dest).isDirectory()) {
-            // 目录（如 pending/archive/）逐个合并子项
-            for (const child of fs.readdirSync(srcPath))
-                moveIntoDir(path.join(srcPath, child), dest, stamp);
-            fs.rmdirSync(srcPath);
-            return;
-        }
-        const ext = path.extname(name);
-        dest = path.join(destDir, `${path.basename(name, ext)}-${stamp}${ext}`);
-    }
-    fs.renameSync(srcPath, dest);
-}
-/**
- * 整理会话结束后的收尾，task:completed / task:error / task:interrupted 都走这里。
- *   - processing/ 里的 note：成功 → archive/notes/，失败 → 归还 pending/（下次重试）
- *   - processing/ 里的其他条目（如 pending/archive/）原样还回 pending/
- *   - 成功才写 checkpoint，失败时下次整理仍取同一段增量消息
- *   - ops 汇总无论成败都写
- * 幂等：processing/ 不存在时只写汇总。
- */
-export async function onConsolidationComplete(params) {
-    const now = params.now ?? Date.now();
-    const stamp = new Date(now).toISOString().replace(/[-:]/g, '').slice(0, 15);
-    const result = { moved: 0, checkpointWritten: false };
-    if (params.memoryDir) {
-        const processingDir = path.join(params.memoryDir, 'processing');
-        if (fs.existsSync(processingDir)) {
-            const pendingDir = path.join(params.memoryDir, 'pending');
-            const noteDest = params.success ? path.join(params.memoryDir, 'archive', 'notes') : pendingDir;
-            fs.mkdirSync(noteDest, { recursive: true });
-            fs.mkdirSync(pendingDir, { recursive: true });
-            for (const entry of fs.readdirSync(processingDir)) {
-                const src = path.join(processingDir, entry);
-                const isNote = entry.endsWith('.md') && fs.statSync(src).isFile();
-                moveIntoDir(src, isNote ? noteDest : pendingDir, stamp);
-                if (isNote)
-                    result.moved++;
-            }
-            fs.rmdirSync(processingDir);
-            result.movedTo = noteDest;
-        }
-    }
-    if (params.success && params.chatDir) {
-        const { writeCheckpoint } = await import('./consolidation-context.js');
-        writeCheckpoint(params.chatDir, now);
-        result.checkpointWritten = true;
-    }
-    const { summarizeOpsRecords, appendOpsRecord } = await import('./consolidation-ops-records.js');
-    appendOpsRecord(params.batchDir, summarizeOpsRecords(params.batchDir));
-    logger.info(`[Memory] 整理收尾（${params.success ? '成功' : '失败'}）：归位 ${result.moved} 条 note` +
-        `${result.movedTo ? ` → ${result.movedTo}` : ''}，checkpoint=${result.checkpointWritten}`);
-    return result;
-}
-/** 会话结束后把产出回填到批次任务书。 */
-export function recordConsolidationOutcome(contextFilePath, outcome) {
-    try {
-        fs.appendFileSync(contextFilePath, `\n---\n\n## 本次产出\n\n${outcome}\n`, 'utf-8');
-    }
-    catch { /* ignore */ }
-}
-/**
- * 整理会话失败/中断时，依据 ops.jsonl 逐条回撤成功的写操作。
- * 回撤顺序：倒序（最后写的先撤）。
- *
- *   create → 删除写入的文件，若有 archivedFiles 将其还原回 consolidated/
- *   update → 用 prevTags 重写文件（恢复修改前的标签，不改 updatedAt 以外的内容）
- *   archive → 将文件从 archivedTo 移回 sourceFile
- */
-export async function rollbackConsolidation(batchDir, selfAid) {
-    const { readRollbackRecords, appendOpsRecord } = await import('./consolidation-ops-records.js');
-    const entries = readRollbackRecords(batchDir);
-    let rolledBack = 0;
-    const errors = [];
-    for (const entry of entries) {
-        try {
-            if (entry.op === 'create') {
-                // 删除写入的文件
-                if (entry.filePath && fs.existsSync(entry.filePath)) {
-                    fs.unlinkSync(entry.filePath);
-                }
-                // 还原被归档的旧文件
-                for (const af of (entry.archivedFiles ?? [])) {
-                    if (af.archivedTo && fs.existsSync(af.archivedTo)) {
-                        const dest = af.source.includes('/') || af.source.includes('\\')
-                            ? af.source
-                            : path.join(path.dirname(af.archivedTo), path.basename(af.archivedTo));
-                        fs.mkdirSync(path.dirname(dest), { recursive: true });
-                        fs.renameSync(af.archivedTo, dest);
-                    }
-                }
-                rolledBack++;
-            }
-            else if (entry.op === 'update') {
-                // 恢复修改前的 tags：读文件、替换 tags 行、重写（不重签名，仅文本恢复）
-                const target = entry.target;
-                if (target && fs.existsSync(target)) {
-                    const raw = fs.readFileSync(target, 'utf-8');
-                    const prevTags = entry.prevTags ?? [];
-                    const tagsLine = prevTags.length > 0 ? `tags: [${prevTags.join(', ')}]` : '';
-                    // 替换 tags: [...] 行；若 prevTags 为空则移除该行
-                    const updated = raw.replace(/^tags: \[.*\]$/m, tagsLine).replace(/^\n$/, '');
-                    fs.writeFileSync(target, updated, 'utf-8');
-                    rolledBack++;
-                }
-            }
-            else if (entry.op === 'archive') {
-                // 将文件从 archivedTo 移回 sourceFile
-                if (entry.archivedTo && entry.sourceFile && fs.existsSync(entry.archivedTo)) {
-                    fs.mkdirSync(path.dirname(entry.sourceFile), { recursive: true });
-                    fs.renameSync(entry.archivedTo, entry.sourceFile);
-                    rolledBack++;
-                }
-            }
-        }
-        catch (e) {
-            const msg = `回撤 ${entry.op} "${entry.target}" 失败: ${e?.message}`;
-            errors.push(msg);
-            logger.warn(`[Memory] ${msg}`);
-        }
-    }
-    appendOpsRecord(batchDir, {
-        ts: new Date().toISOString(),
-        op: 'session-end',
-        success: false,
-        movedNotes: 0,
-        checkpointWritten: false,
-    });
-    logger.info(`[Memory] 回撤完成：回撤 ${rolledBack} 条操作，${errors.length} 个失败`);
-    return { rolledBack, errors };
-}
-export { resolveRoot };