evolcore 0.0.32 → 0.0.34

package/dist/core/file-integrity/store.js

@@ -0,0 +1,262 @@
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { createRequire } from 'module';
+import { integrityDbPath, integritySnapshotDir, resolveRoot } from '../../paths.js';
+import { logger } from '../../utils/logger.js';
+// 项目是 ESM，裸 require 不存在；与 codex-session-file-adapter 同款懒加载
+const requireFromHere = createRequire(import.meta.url);
+// ── SQLite 懒加载 ─────────────────────────────────────────────────────────────
+let _db = null;
+const CREATE_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS file_integrity (
+    file_path        TEXT PRIMARY KEY,
+    sha256           TEXT NOT NULL,
+    registered_at    INTEGER NOT NULL,
+    last_verified_at INTEGER,
+    registrar_aid    TEXT
+  )
+`;
+function getDb() {
+    if (_db)
+        return _db;
+    // node:sqlite (DatabaseSync) 在 Node 22.5+ 可用，懒加载兼容低版本
+    let DatabaseSync;
+    try {
+        ({ DatabaseSync } = requireFromHere('node:sqlite'));
+    }
+    catch {
+        throw new Error('[file-integrity] node:sqlite 不可用，需要 Node.js 22.5+');
+    }
+    fs.mkdirSync(path.dirname(integrityDbPath()), { recursive: true });
+    _db = new DatabaseSync(integrityDbPath());
+    // CLI 进程和 daemon 可能同时打开同一个库：先设等待，再切 WAL
+    _db.exec('PRAGMA busy_timeout = 5000');
+    _db.exec('PRAGMA journal_mode = WAL');
+    _db.exec(CREATE_TABLE_SQL);
+    return _db;
+}
+// ── 快照路径规范化 ────────────────────────────────────────────────────────────
+/**
+ * 台账主键：绝对路径 + 正斜杠；Windows 文件系统大小写不敏感，再统一转小写，
+ * 避免 `Evol` / `evol` 这类同一文件两种写法登记成两条。
+ */
+function recordKey(filePath) {
+    const normalized = path.resolve(filePath).replace(/\\/g, '/');
+    return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+function snapshotPath(key) {
+    const rootKey = recordKey(resolveRoot());
+    if (key.startsWith(rootKey + '/')) {
+        return path.join(integritySnapshotDir(), key.slice(rootKey.length + 1));
+    }
+    // 路径在 home 外（如包内 kits/），用 key 的 sha256 命名，防路径穿越和盘符冒号
+    const hash = crypto.createHash('sha256').update(key).digest('hex');
+    return path.join(integritySnapshotDir(), hash);
+}
+// ── SHA-256 计算 ──────────────────────────────────────────────────────────────
+function computeSha256(bytes) {
+    return crypto.createHash('sha256').update(bytes).digest('hex');
+}
+/** 快照存在且内容与台账一致，才算可恢复 */
+function snapshotIntact(key, expected) {
+    const snap = snapshotPath(key);
+    return fs.existsSync(snap) && computeSha256(fs.readFileSync(snap)) === expected;
+}
+// ── 原子写文件（tmp → rename） ────────────────────────────────────────────────
+function atomicWrite(destPath, bytes) {
+    // 带 pid：恢复写盘不在事务里，daemon 与 CLI 同时恢复同一文件时不能共用临时名
+    const tmpPath = `${destPath}.integrity-tmp-${process.pid}`;
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+    fs.writeFileSync(tmpPath, bytes);
+    fs.renameSync(tmpPath, destPath);
+}
+// ── 日志（复用 daemon logger，固定前缀便于过滤） ─────────────────────────────
+function short(hash) {
+    return hash.slice(0, 12);
+}
+// ── 核心 API ──────────────────────────────────────────────────────────────────
+/**
+ * 登记文件到台账并备份快照。
+ * 在文件写入完成后由写入方调用，建立或更新可信基线。
+ */
+export function registerFile(filePath, aid) {
+    const key = recordKey(filePath);
+    const bytes = fs.readFileSync(filePath);
+    registerBytes(key, bytes, aid, fs.statSync(filePath).mtime);
+    logger.info(`[file-integrity] registered path=${key} sha256=${short(computeSha256(bytes))}${aid ? ` aid=${aid}` : ''}`);
+}
+/**
+ * node:sqlite 没有 transaction() 包装，手写 BEGIN/COMMIT：
+ * 快照写失败则 ROLLBACK，台账不会指向一份不存在的快照。
+ */
+function registerBytes(key, bytes, aid, mtime) {
+    const sha256 = computeSha256(bytes);
+    const now = Math.floor(Date.now() / 1000);
+    const db = getDb();
+    db.exec('BEGIN');
+    try {
+        db.prepare(`INSERT INTO file_integrity (file_path, sha256, registered_at, registrar_aid)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(file_path) DO UPDATE SET
+         sha256 = excluded.sha256,
+         registered_at = excluded.registered_at,
+         registrar_aid = excluded.registrar_aid`).run(key, sha256, now, aid ?? null);
+        const snap = snapshotPath(key);
+        atomicWrite(snap, bytes);
+        // 快照带上原文件 mtime，恢复时还原回去；记忆的排序和超期判断都读 mtime
+        if (mtime)
+            fs.utimesSync(snap, mtime, mtime);
+        db.exec('COMMIT');
+    }
+    catch (err) {
+        try {
+            db.exec('ROLLBACK');
+        }
+        catch { /* ignore */ }
+        throw err;
+    }
+}
+/**
+ * 校验文件完整性。
+ *
+ * - 文件不存在 → missing
+ * - 台账无记录 → 用本次读到的字节自动登记，返回 verified
+ * - sha256 匹配 → verified，更新 last_verified_at
+ * - 不匹配且 restoreOnFail → 快照 sha256 与台账一致则原子恢复，返回 restored；否则 tampered
+ * - 不匹配且未要求恢复 → tampered
+ *
+ * 返回的 bytes 就是本次校验过的内容，调用方直接使用，不要再读一次文件（TOCTOU）。
+ */
+export function verifyFile(filePath, opts) {
+    const key = recordKey(filePath);
+    if (!fs.existsSync(filePath))
+        return { status: 'missing' };
+    const bytes = fs.readFileSync(filePath);
+    const actual = computeSha256(bytes);
+    const db = getDb();
+    const row = db.prepare('SELECT sha256 FROM file_integrity WHERE file_path = ?').get(key);
+    if (!row) {
+        // 用已读字节登记，避免二次读文件时内容已变
+        registerBytes(key, bytes, undefined, fs.statSync(filePath).mtime);
+        logger.info(`[file-integrity] auto-registered path=${key} sha256=${short(actual)}`);
+        return { status: 'verified', bytes };
+    }
+    if (actual === row.sha256) {
+        db.prepare('UPDATE file_integrity SET last_verified_at = ? WHERE file_path = ?')
+            .run(Math.floor(Date.now() / 1000), key);
+        return { status: 'verified', bytes };
+    }
+    const snap = snapshotPath(key);
+    const snapExists = fs.existsSync(snap);
+    if (opts?.restoreOnFail && snapExists) {
+        const snapBytes = fs.readFileSync(snap);
+        if (computeSha256(snapBytes) === row.sha256) {
+            atomicWrite(filePath, snapBytes);
+            // 还原成登记时的 mtime，不让恢复动作把文件"续期"成刚写入
+            try {
+                const { mtime } = fs.statSync(snap);
+                fs.utimesSync(filePath, mtime, mtime);
+            }
+            catch { /* best-effort */ }
+            logger.warn(`[file-integrity] restored path=${key} expected=${short(row.sha256)} actual=${short(actual)}`);
+            return { status: 'restored', bytes: snapBytes };
+        }
+        logger.error(`[file-integrity] snapshot-corrupted path=${key}`);
+        return { status: 'tampered', restorable: false, expected: row.sha256, actual };
+    }
+    const restorable = snapshotIntact(key, row.sha256);
+    logger.warn(`[file-integrity] tampered path=${key} expected=${short(row.sha256)} actual=${short(actual)} restorable=${restorable}`);
+    return { status: 'tampered', restorable, expected: row.sha256, actual };
+}
+/** 只读查询台账记录，不读文件，供诊断和 CLI 使用。 */
+export function queryRecord(filePath) {
+    const row = getDb().prepare('SELECT file_path, sha256, registered_at, last_verified_at, registrar_aid FROM file_integrity WHERE file_path = ?').get(recordKey(filePath));
+    return row ?? null;
+}
+/**
+ * 文件经正规渠道 rename 后调用：台账主键和快照一起搬到新路径，sha256 不变。
+ * 搬移前后的篡改都会在新路径上被校验出来。rename 后不要对新路径重新 registerFile，
+ * 那会把搬移前的篡改登记成新基线。
+ */
+export function moveRecord(fromPath, toPath) {
+    const fromKey = recordKey(fromPath);
+    const toKey = recordKey(toPath);
+    if (fromKey === toKey)
+        return;
+    const db = getDb();
+    const row = db.prepare('SELECT 1 FROM file_integrity WHERE file_path = ?').get(fromKey);
+    if (!row) {
+        // 源文件从未登记过，没有可搬的基线；新路径下次 verify 时自动登记
+        logger.warn(`[file-integrity] move-without-record from=${fromKey} to=${toKey}`);
+        return;
+    }
+    const fromSnap = snapshotPath(fromKey);
+    const toSnap = snapshotPath(toKey);
+    db.exec('BEGIN');
+    try {
+        db.prepare('DELETE FROM file_integrity WHERE file_path = ?').run(toKey);
+        db.prepare('UPDATE file_integrity SET file_path = ? WHERE file_path = ?').run(toKey, fromKey);
+        if (fs.existsSync(fromSnap)) {
+            fs.mkdirSync(path.dirname(toSnap), { recursive: true });
+            fs.renameSync(fromSnap, toSnap);
+        }
+        else {
+            fs.rmSync(toSnap, { force: true });
+        }
+        db.exec('COMMIT');
+    }
+    catch (err) {
+        try {
+            db.exec('ROLLBACK');
+        }
+        catch { /* ignore */ }
+        throw err;
+    }
+    logger.info(`[file-integrity] moved from=${fromKey} to=${toKey}`);
+}
+/** 文件经正规渠道删除后调用：删掉台账记录和快照。 */
+export function unregisterFile(filePath) {
+    const key = recordKey(filePath);
+    const result = getDb().prepare('DELETE FROM file_integrity WHERE file_path = ?').run(key);
+    fs.rmSync(snapshotPath(key), { force: true });
+    if (Number(result?.changes ?? 0) > 0)
+        logger.info(`[file-integrity] unregistered path=${key}`);
+}
+/**
+ * 登记一段**尚未落盘**的内容。写盘之前调用。
+ *
+ * 为什么不在写完之后登记：写方和读方可能不在同一个进程（daemon 与 CLI）。
+ * 若先改盘再登记，中间那个窗口里另一个进程读到的就是"新内容 + 旧台账"，
+ * 会被判成篡改并回滚掉刚写进去的合法内容。
+ *
+ * 配置类文件不靠 mtime 判断超期，所以这里用登记时刻作快照 mtime。
+ */
+export function registerContent(filePath, content, aid) {
+    const key = recordKey(filePath);
+    const bytes = Buffer.isBuffer(content) ? content : Buffer.from(content, 'utf-8');
+    registerBytes(key, bytes, aid);
+}
+/** 只读检查，不改台账、不恢复文件，也不更新 last_verified_at。供诊断和 CLI 使用。 */
+export function checkFile(filePath) {
+    const key = recordKey(filePath);
+    if (!fs.existsSync(filePath))
+        return { status: 'missing' };
+    const actual = computeSha256(fs.readFileSync(filePath));
+    const row = getDb().prepare('SELECT sha256 FROM file_integrity WHERE file_path = ?').get(key);
+    if (!row)
+        return { status: 'unregistered', actual };
+    if (row.sha256 === actual)
+        return { status: 'verified', expected: row.sha256, actual };
+    return { status: 'tampered', expected: row.sha256, actual, restorable: snapshotIntact(key, row.sha256) };
+}
+/** 仅供测试：关闭并重置 SQLite 连接缓存 */
+export function _resetDb() {
+    if (_db) {
+        try {
+            _db.close();
+        }
+        catch { /* ignore */ }
+        _db = null;
+    }
+}

package/dist/core/handoff/runtime.js

@@ -33,13 +33,6 @@ export class HandoffDeliveryFailedError extends Error {
         this.name = 'HandoffDeliveryFailedError';
     }
 }
-export class HandoffReturnPolicyRequiredError extends Error {
-    code = 'HANDOFF_RETURN_POLICY_REQUIRED';
-    constructor() {
-        super('跨会话 ec msg/group send 必须显式指定 --return none|required');
-        this.name = 'HandoffReturnPolicyRequiredError';
-    }
-}
 export class TriggerHandoffRequiredForbiddenError extends Error {
     code = 'TRIGGER_HANDOFF_REQUIRED_FORBIDDEN';
     constructor() {
@@ -99,9 +92,10 @@ export class HandoffRuntime {
                 throw new Error('handoff context requires a different target session');
             return { crossSession: false, targetSession: target };
         }
-        if (!input.explicitReturnPolicy)
-            throw new HandoffReturnPolicyRequiredError();
-        if (input.explicitReturnPolicy === 'required' && input.causation?.trigger?.path.length) {
+        // --return 参数已废弃：跨会话 send 不再要求显式指定返回策略，默认 'none'。
+        // 内部调用方（agent-create 等）仍可显式传 'required' 走回流路径。
+        const effectiveReturnPolicy = input.explicitReturnPolicy ?? 'none';
+        if (effectiveReturnPolicy === 'required' && input.causation?.trigger?.path.length) {
             throw new TriggerHandoffRequiredForbiddenError();
         }
         const handoffCausation = deriveCausation(normalizeCausation(input.causation) ?? createRootCausation());
@@ -127,7 +121,7 @@ export class HandoffRuntime {
                 delivery: targetChatType === 'group'
                     ? { chatType: 'group', groupId: input.to }
                     : { chatType: 'private' },
-                returnPolicy: input.explicitReturnPolicy ?? 'required',
+                returnPolicy: effectiveReturnPolicy,
                 originAuthorization: input.originAuthorization,
                 causation: handoffCausation,
                 now: this.now?.(),

package/dist/core/handoff/store.js

@@ -1,3 +1,8 @@
+/**
+ * @deprecated Handoff 机制已被 Thread Context 取代，见
+ * `docs/thread-chain/handoff-deprecation.md`。保留仅为兼容在途 handoff，
+ * 将在清理阶段删除。
+ */
 import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';

package/dist/core/ipc-registration.js

@@ -1,4 +1,5 @@
 import { TriggerDefinitionManager } from '../trigger/manager.js';
+import { ensureSessionRuntimeDir } from '../cli/task-context.js';
 import { logger } from '../utils/logger.js';
 import crypto from 'crypto';
 import fs from 'fs';
@@ -6,6 +7,10 @@ import path from 'path';
 import { executeTaskResume } from './task/task-resume-operation.js';
 import { isHClassPath, isLClassPath, isSameOrDescendant } from './permission/protected-paths.js';
 import { resolveStorageCommandArgv } from '../aun/storage/index.js';
+import { agentDir } from '../paths.js';
+import { parsePeerKey } from './relation/peer-identity.js';
+import { resolvePeerRoleDetail } from '../config/peer-role-resolver.js';
+import { buildDebugTaskContext } from './auth/debug-context.js';
 import { computeBuildId } from '../utils/evolcore-version.js';
 import { loadAgent } from '../config-store.js';
 import { executeLocalInitializationCommand, hasSuppliedInitialization } from '../cli/agent-create.js';
@@ -17,7 +22,9 @@ import { registerHandoffIpc } from './handoff/ipc-registration.js';
 import { registerAunIpcSender } from './message/aun-ipc-sender.js';
 import { registerConsolidationCheckExecutor, registerConsolidationLaunchExecutor, } from './memory/consolidation.js';
 import { createTriggerBaseagentResolver, registerTriggerIpcExecutor } from '../trigger/ipc-service.js';
+import { createThreadOperationExecutor } from './thread/ipc-operation.js';
 import { isLinkedInstall } from '../utils/npm-ops.js';
+import { buildSystemSessionContext, getSystemSessionModule } from './system-session/registry.js';
 export function registerDaemonIpc({ ipcServer, agentRegistry, agentDelegationRegistry, sessionManager, statsCollector, aidStatsCollector, responseEngine, messageQueue, agentMap, commandHandler, channelInstances, eventBus, handoffRuntime, reloadCoordinator, agentApplicationService, agentInitializationService, enqueueConsolidation, completeAgentBootstrap, contactBinds, bindService, diagService, getProcessOwners, getControlAidState, daemonAid, triggerControlToken, triggerSchedulers, daemonTriggerOwner, primaryAgent, triggerAuthorization, }) {
     const authorizeManagedAgentOperation = createDelegationAuthorizer({
         agentDelegationRegistry,
@@ -52,6 +59,137 @@ export function registerDaemonIpc({ ipcServer, agentRegistry, agentDelegationReg
         agentMap,
         isLinkedInstall: isLinkedInstall(),
     });
+    if (process.env.EVOLCORE_DEBUG_MODE === '1') {
+        ipcServer.setDebugIssueTokenExecutor(async ({ sessionId }) => {
+            try {
+                const activeContext = responseEngine.getTaskRuntimeContext(sessionId);
+                let runtimeContext = activeContext;
+                if (!runtimeContext) {
+                    const session = await sessionManager.getSessionById(sessionId);
+                    if (!session)
+                        return { ok: false, error: `session not found: ${sessionId}` };
+                    runtimeContext = buildDebugTaskContext({
+                        session,
+                        getTrigger: (agentAid, triggerId) => new TriggerDefinitionManager(agentAid).get(triggerId),
+                        sessionRuntimeDir: ensureSessionRuntimeDir(session.id),
+                    });
+                }
+                if (!runtimeContext.selfAid)
+                    return { ok: false, error: 'debug session has no selfAid' };
+                const channelType = runtimeContext.channel || 'aun';
+                const channel = runtimeContext.channelKey || channelType;
+                const peerKeyId = (() => {
+                    try {
+                        return parsePeerKey(runtimeContext.peerKey || '').channelId;
+                    }
+                    catch {
+                        return runtimeContext.peerId || runtimeContext.channelId || '';
+                    }
+                })();
+                const chatType = runtimeContext.chatType === 'group' ? 'group' : 'private';
+                const conversationId = chatType === 'group'
+                    ? (runtimeContext.channelId || peerKeyId)
+                    : peerKeyId;
+                const peerRole = resolvePeerRoleDetail({
+                    selfAid: runtimeContext.selfAid,
+                    channelKey: channel,
+                    channelType,
+                    chatType,
+                    actorId: peerKeyId,
+                    conversationId,
+                });
+                const token = agentDelegationRegistry.issueDebug({
+                    sessionId,
+                    selfAid: runtimeContext.selfAid,
+                    channel,
+                    channelType,
+                    chatType,
+                    peerKey: runtimeContext.peerKey || '',
+                    actorId: peerKeyId || runtimeContext.selfAid,
+                    issuedRole: peerRole.effectiveRole || 'none',
+                });
+                return { ok: true, token, runtimeContext };
+            }
+            catch (error) {
+                return { ok: false, error: error instanceof Error ? error.message : String(error) };
+            }
+        });
+    }
+    ipcServer.setThreadOperationExecutor(createThreadOperationExecutor({
+        sessionManager,
+        agentDelegationRegistry,
+        getProcessOwners,
+        sendSystemMsg: async (params) => {
+            if (ipcServer.hasAunMsgSender()) {
+                const sent = await ipcServer.sendAunMsg({
+                    aid: params.from,
+                    to: params.to,
+                    scope: params.peerKind === 'group' ? 'group' : 'msg',
+                    payload: { type: 'topic-created', topicName: params.topicName, threadId: params.threadId },
+                    thread: params.threadId,
+                });
+                if (!sent?.ok)
+                    throw new Error(sent?.error || 'Topic notification failed');
+            }
+        },
+        onDeleted: (aid, threadId) => {
+            const scheduler = triggerSchedulers.get(aid);
+            if (scheduler) {
+                const related = scheduler.list({ all: true }).filter((trigger) => trigger.origin?.threadId === threadId
+                    || trigger.labels?.originThreadId === threadId
+                    || trigger.labels?.targetThreadId === threadId);
+                for (const trigger of related) {
+                    try {
+                        scheduler.delete(trigger.id);
+                    }
+                    catch { }
+                }
+            }
+        },
+    }));
+    ipcServer.setSkillRefreshExecutor(async (aid, sessionId, delegationToken, delegationCommandHash) => {
+        const fail = (code, error) => ({ ok: false, code, error });
+        if (!agentRegistry.get(aid))
+            return fail('AGENT_NOT_FOUND', `Agent "${aid}" not found`);
+        if (sessionId) {
+            const authorization = await authorizeManagedAgentOperation({
+                sessionId,
+                delegationToken,
+                delegationCommandHash,
+                targetAid: aid,
+            }, 'skill.refresh');
+            if (!authorization.ok)
+                return fail(authorization.code, authorization.error);
+        }
+        try {
+            const { refreshSkillIndex } = await import('./skill/startup.js');
+            refreshSkillIndex(agentDir(aid), aid);
+            const skillsDir = path.join(agentDir(aid), 'skills');
+            return {
+                ok: true,
+                result: {
+                    aid,
+                    builtinIndexPath: path.join(skillsDir, '.index-builtin.md'),
+                    localIndexPath: path.join(skillsDir, '.index-local.md'),
+                },
+            };
+        }
+        catch (error) {
+            return fail('INTERNAL', error?.message || String(error));
+        }
+    });
+    commandHandler.setSkillIndexRefresher(async (aid) => {
+        if (!agentRegistry.get(aid))
+            return { ok: false, error: `Agent "${aid}" not found` };
+        try {
+            const { refreshSkillIndex } = await import('./skill/startup.js');
+            refreshSkillIndex(agentDir(aid), aid);
+            return { ok: true };
+        }
+        catch (error) {
+            return { ok: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    });
     registerHandoffIpc({
         ipcServer,
         agentDelegationRegistry,
@@ -61,7 +199,7 @@ export function registerDaemonIpc({ ipcServer, agentRegistry, agentDelegationReg
         handoffRuntime,
         getProcessOwners,
     });
-    registerAunIpcSender({ ipcServer, channelInstances, agentDelegationRegistry, responseEngine, handoffRuntime });
+    registerAunIpcSender({ ipcServer, channelInstances, agentDelegationRegistry, responseEngine, handoffRuntime, triggerSchedulers });
     ipcServer.setAgentReloadExecutor((aid, options) => reloadCoordinator.reload(aid, options));
     registerConsolidationCheckExecutor({ ipcServer, agentRegistry, enqueueConsolidation });
     ipcServer.setInitializationExecutor(async (command) => executeLocalInitializationCommand(agentInitializationService, command));
@@ -212,7 +350,7 @@ export function registerRuntimeIpcProviders({ ipcServer, channelInstances, messa
             const session = await sessionManager.getSessionById(sessionId);
             if (!session)
                 return null;
-            const { buildDebugTaskContext } = await import('./memory/consolidation.js');
+            const { buildDebugTaskContext } = await import('./auth/debug-context.js');
             const { ensureSessionRuntimeDir } = await import('../cli/task-context.js');
             return buildDebugTaskContext({
                 session,
@@ -222,6 +360,31 @@ export function registerRuntimeIpcProviders({ ipcServer, channelInstances, messa
         });
         logger.info('[Memory] 开发仓安装：已启用 ec memory --debug <sessionId>');
     }
+    ipcServer.setSystemSessionCommandGate(async ({ sessionId, delegationToken, delegationCommandHash, type, argv }) => {
+        // 只读查询，不消耗已审批命令
+        const validation = agentDelegationRegistry.validateForContext(delegationToken, sessionId, delegationCommandHash);
+        const marker = validation.ok ? validation.grant.systemSession : undefined;
+        if (!validation.ok || !marker)
+            return undefined;
+        const module = getSystemSessionModule(marker.type);
+        if (!module)
+            return { allow: false, code: 'system_session_unknown', reason: `未注册的系统会话类型: ${marker.type}` };
+        // 无 argv 的请求只放行任务上下文查询（ec 命令取自身上下文用）
+        if (!argv) {
+            return type === 'task-runtime-context'
+                ? { allow: true }
+                : { allow: false, code: 'system_session_command_forbidden', reason: `系统会话不允许调用 ${type}` };
+        }
+        const session = await sessionManager.getSessionById(sessionId);
+        const ctx = buildSystemSessionContext({
+            marker,
+            sessionId,
+            selfAid: validation.grant.selfAid,
+            projectPath: session?.projectPath ?? '',
+            metadata: session?.metadata,
+        });
+        return module.checkCommand(argv, ctx);
+    });
     ipcServer.setTaskRuntimeContextAuthorizer(({ sessionId, delegationToken, delegationCommandHash, consumeApproval }) => {
         if (consumeApproval && !agentDelegationRegistry.validate)
             return { ok: false, code: 'DELEGATION_REQUIRED', error: 'Command authorization is unavailable' };
@@ -230,8 +393,17 @@ export function registerRuntimeIpcProviders({ ipcServer, channelInstances, messa
             : agentDelegationRegistry.validateForContext(delegationToken, sessionId, delegationCommandHash);
         return authorization.ok
             ? { ok: true }
-            : { ok: false, code: authorization.code, error: authorization.reason };
+            : {
+                ok: false,
+                code: authorization.code,
+                error: authorization.reason,
+                diagnosticCause: authorization.diagnosticCause,
+                ...(authorization.diagnosticEventId ? { diagnosticEventId: authorization.diagnosticEventId } : {}),
+            };
     });
+    if (agentDelegationRegistry.recordDiagnosticFailure) {
+        ipcServer.setDelegationFailureRecorder(agentDelegationRegistry.recordDiagnosticFailure.bind(agentDelegationRegistry));
+    }
     ipcServer.setCodexPreToolUseExecutor(async (params) => {
         for (const runner of new Set(agentMap.values())) {
             if (typeof runner?.evaluatePreToolUse !== 'function')

package/dist/core/memory/batch-meta.js

@@ -0,0 +1,132 @@
+/**
+ * batch-meta.ts — 整理批次元数据文件（batch.md）
+ *
+ * 格式：YAML frontmatter + 正文（feedback 内容）
+ *
+ *   ---
+ *   executionSessionId: memory_20261015T000000_abc
+ *   selfAid: dddd.agentid.pub
+ *   mode: notes
+ *   ...
+ *   ---
+ *
+ *   ## 整理反馈
+ *
+ *   <feedback 正文>
+ *
+ * 在 batchDir 创建时写入初始元数据（status=running），会话结束时更新状态、填入 feedback。
+ */
+import fs from 'fs';
+import path from 'path';
+const BATCH_MD = 'batch.md';
+const FEEDBACK_HEADING = '## 整理反馈';
+// ── frontmatter 序列化 / 解析 ──────────────────────────────────────────────
+function serializeFrontmatter(meta) {
+    const lines = ['---'];
+    for (const [k, v] of Object.entries(meta)) {
+        if (v === undefined)
+            continue;
+        lines.push(`${k}: ${String(v)}`);
+    }
+    lines.push('---');
+    return lines.join('\n');
+}
+function parseFrontmatter(content) {
+    if (!content.startsWith('---'))
+        return { meta: {}, body: content };
+    const end = content.indexOf('\n---', 3);
+    if (end === -1)
+        return { meta: {}, body: content };
+    const block = content.slice(4, end);
+    const body = content.slice(end + 4).replace(/^\n/, '');
+    const meta = {};
+    for (const line of block.split('\n')) {
+        const sep = line.indexOf(':');
+        if (sep === -1)
+            continue;
+        const key = line.slice(0, sep).trim();
+        const val = line.slice(sep + 1).trim();
+        if (val === 'true')
+            meta[key] = true;
+        else if (val === 'false')
+            meta[key] = false;
+        else if (val === '')
+            meta[key] = undefined;
+        else
+            meta[key] = val;
+    }
+    return { meta: meta, body };
+}
+function batchMdPath(batchDir) {
+    return path.join(batchDir, BATCH_MD);
+}
+// ── 公开 API ───────────────────────────────────────────────────────────────
+/**
+ * 创建 batchDir 后立即写入初始 batch.md（status=running，无 feedback 正文）。
+ * 文件已存在时跳过（重入保护）。
+ */
+export function writeBatchMeta(batchDir, meta) {
+    try {
+        fs.mkdirSync(batchDir, { recursive: true });
+        const filePath = batchMdPath(batchDir);
+        if (fs.existsSync(filePath))
+            return;
+        const content = serializeFrontmatter(meta) + '\n';
+        fs.writeFileSync(filePath, content, 'utf-8');
+    }
+    catch { /* 失败静默，不影响主流程 */ }
+}
+/**
+ * 会话结束时更新 batch.md：
+ * - 合并 frontmatter 字段（status / finishedAt / success / agentSessionId）
+ * - 如果 feedbackText 非空，写入或替换「## 整理反馈」段落
+ */
+export function updateBatchMeta(batchDir, updates) {
+    try {
+        const filePath = batchMdPath(batchDir);
+        if (!fs.existsSync(filePath))
+            return;
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const { meta, body } = parseFrontmatter(raw);
+        // 合并字段
+        const updated = {
+            ...meta,
+            status: updates.status,
+            finishedAt: updates.finishedAt,
+            success: updates.success,
+            ...(updates.agentSessionId ? { agentSessionId: updates.agentSessionId } : {}),
+        };
+        // 更新 feedback 正文
+        let newBody = body;
+        if (updates.feedbackText) {
+            const feedbackBlock = `${FEEDBACK_HEADING}\n\n${updates.feedbackText}\n`;
+            const headingIdx = newBody.indexOf(FEEDBACK_HEADING);
+            if (headingIdx !== -1) {
+                // 替换已有段落
+                newBody = newBody.slice(0, headingIdx) + feedbackBlock;
+            }
+            else {
+                newBody = (newBody ? newBody.trimEnd() + '\n\n' : '') + feedbackBlock;
+            }
+        }
+        const result = serializeFrontmatter(updated) + '\n' + (newBody ? '\n' + newBody : '');
+        fs.writeFileSync(filePath, result, 'utf-8');
+    }
+    catch { /* 失败静默 */ }
+}
+/**
+ * 读取 batch.md 的 frontmatter（解析失败返回 undefined）。
+ */
+export function readBatchMeta(batchDir) {
+    try {
+        const filePath = batchMdPath(batchDir);
+        if (!fs.existsSync(filePath))
+            return undefined;
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const { meta } = parseFrontmatter(raw);
+        return Object.keys(meta).length > 0 ? meta : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}