evolcore 0.0.10 → 0.0.12

package/dist/ipc.js

@@ -1,17 +1,37 @@
 import net from 'net';
 import fs from 'fs';
+import crypto from 'crypto';
 import os from 'os';
 import path from 'path';
 import { logger } from './utils/logger.js';
 import { fileCache } from './core/daemon-file-cache.js';
 import { HANDOFF_QUERY_MAX_LIMIT, HANDOFF_STATES } from './core/handoff/types.js';
+import { AgentReloadBusyError } from './core/agent-reload-coordinator.js';
 import { resolvePaths } from './paths.js';
 import { getProcessStartTime, isSameOrOlderProcess } from './utils/process-introspect.js';
 import { classifyProcessTree, ProcessTreeSampler } from './utils/process-tree-stats.js';
 import { readSystemMemoryUsage } from './utils/system-memory.js';
 import { hashCurrentDelegatedCommand } from './core/auth/agent-delegation.js';
+import { normalizeAunMentionEntries } from './aun/msg/mention-schema.js';
 const isWindows = process.platform === 'win32';
 const isNamedPipe = (p) => isWindows && p.startsWith('\\\\.\\pipe\\');
+const LOCAL_CONTROL_COMMANDS = new Set([
+    'bind.begin',
+    'bind.status',
+    'bind.cancel',
+    'dingtalk.contact-bind.register',
+    'feishu.contact-bind.register',
+    'qqbot.contact-bind.register',
+    'wecom.contact-bind.register',
+    'wechat.contact-bind.register',
+    'queue-snapshot',
+    'aun-aid-stats-record-outbound',
+    'evolagent.reload',
+    'evolagent.load',
+    'evolagent.resync',
+    'menu.exec',
+    'monitor-snapshot',
+]);
 export function summarizeMonitorAgents(agents, aids) {
     const connectedAgents = new Set(aids.filter(aid => aid.status === 'connected').map(aid => aid.agentName || aid.aid));
     const enabledAgents = agents.filter(agent => agent.status !== 'disabled');
@@ -38,8 +58,14 @@ export class IpcServer {
     agentStatsProvider;
     queueSnapshotProvider;
     queueActionExecutor;
+    queueOperationExecutor;
+    statusAuthorizationExecutor;
+    storageAuthorizationExecutor;
     triggerExecutor;
+    bootstrapCompleteExecutor;
+    agentReloadExecutor;
     taskRuntimeContextProvider;
+    codexPreToolUseExecutor;
     aunMsgSender;
     handoffReturnExecutor;
     handoffStatusExecutor;
@@ -48,11 +74,16 @@ export class IpcServer {
     bindExecutor;
     configOperationExecutor;
     contactOperationExecutor;
+    aidOperationExecutor;
+    groupOperationExecutor;
+    msgOperationExecutor;
+    fsOperationExecutor;
     dingtalkContactBindExecutor;
     feishuContactBindExecutor;
     qqbotContactBindExecutor;
     wecomContactBindExecutor;
     wechatContactBindExecutor;
+    controlToken;
     // CPU 占用追踪：IPC handler 是一次性同步调用，无法在响应里做 200ms 异步采样，
     // 故用后台 1s interval 累积 process.cpuUsage() 增量，handler 直接读最近值。
     // procCpuPercent = 本 daemon 进程占单核的百分比（可 >100% 仅当多核，已 clamp 到 100）；
@@ -75,6 +106,10 @@ export class IpcServer {
     setAgentRegistry(registry) {
         this.agentRegistry = registry;
     }
+    /** Authenticate local control-plane callers that cannot use task delegation. */
+    setControlToken(token) {
+        this.controlToken = Buffer.from(token);
+    }
     /** Inject menu.* executor (ECWeb Control proxies menu requests through this) */
     setMenuExecutor(executor) {
         this.menuExecutor = executor;
@@ -85,6 +120,21 @@ export class IpcServer {
     setContactOperationExecutor(executor) {
         this.contactOperationExecutor = executor;
     }
+    setAidOperationExecutor(executor) {
+        this.aidOperationExecutor = executor;
+    }
+    setGroupOperationExecutor(executor) {
+        this.groupOperationExecutor = executor;
+    }
+    setMsgOperationExecutor(executor) {
+        this.msgOperationExecutor = executor;
+    }
+    setFsOperationExecutor(executor) {
+        this.fsOperationExecutor = executor;
+    }
+    setAgentReloadExecutor(executor) {
+        this.agentReloadExecutor = executor;
+    }
     /** Inject AUN AID state aggregator for aun-aids IPC handler */
     setAunAidProvider(provider) {
         this.aunAidProvider = provider;
@@ -113,14 +163,30 @@ export class IpcServer {
     setQueueActionExecutor(executor) {
         this.queueActionExecutor = executor;
     }
+    setQueueOperationExecutor(executor) {
+        this.queueOperationExecutor = executor;
+    }
+    setStatusAuthorizationExecutor(executor) {
+        this.statusAuthorizationExecutor = executor;
+    }
+    setStorageAuthorizationExecutor(executor) {
+        this.storageAuthorizationExecutor = executor;
+    }
     /** Inject daemon-level trigger executor for ec trigger. */
     setTriggerExecutor(executor) {
         this.triggerExecutor = executor;
     }
+    /** Complete an agent bootstrap in the daemon so disk and runtime state change together. */
+    setBootstrapCompleteExecutor(executor) {
+        this.bootstrapCompleteExecutor = executor;
+    }
     /** Inject active task runtime-context provider for in-task CLI routing. */
     setTaskRuntimeContextProvider(provider) {
         this.taskRuntimeContextProvider = provider;
     }
+    setCodexPreToolUseExecutor(executor) {
+        this.codexPreToolUseExecutor = executor;
+    }
     /** Inject daemon-backed AUN private message sender for in-task `ec msg send`. */
     setAunMsgSender(sender) {
         this.aunMsgSender = sender;
@@ -313,9 +379,31 @@ export class IpcServer {
         }
     }
     async handleCommand(cmd) {
+        if (LOCAL_CONTROL_COMMANDS.has(cmd.type) && !this.hasValidControlToken(cmd.controlToken)) {
+            return { ok: false, code: 'INVALID_CONTROL_TOKEN', error: 'valid local control token is required' };
+        }
         switch (cmd.type) {
             case 'status':
                 return this.getStatus();
+            case 'codex-pre-tool-use': {
+                if (!this.codexPreToolUseExecutor) {
+                    return { ok: false, applicable: true, decision: 'deny', reason: 'EvolCore Codex policy executor is unavailable' };
+                }
+                if (typeof cmd.threadId !== 'string' || !cmd.threadId
+                    || typeof cmd.toolName !== 'string' || !cmd.toolName) {
+                    return { ok: false, applicable: true, decision: 'deny', reason: 'invalid Codex hook request' };
+                }
+                try {
+                    return await this.codexPreToolUseExecutor({
+                        threadId: cmd.threadId,
+                        toolName: cmd.toolName,
+                        toolInput: cmd.toolInput,
+                    });
+                }
+                catch (error) {
+                    return { ok: false, applicable: true, decision: 'deny', reason: `EvolCore policy unavailable: ${error instanceof Error ? error.message : String(error)}` };
+                }
+            }
             case 'ping':
                 return { pong: true, pid: process.pid, protocolVersion: 1 };
             case 'bind.begin': {
@@ -325,7 +413,6 @@ export class IpcServer {
                     bindType: cmd.bindType,
                     targetAid: cmd.targetAid,
                     agentName: cmd.agentName,
-                    ownerMode: cmd.ownerMode,
                     ttlMs: cmd.ttlMs,
                 });
             }
@@ -445,6 +532,53 @@ export class IpcServer {
                     sessionKey: cmd.sessionKey,
                 });
             }
+            case 'queue.op': {
+                if (!this.queueOperationExecutor)
+                    return { ok: false, code: 'NOT_CONFIGURED', error: 'queue.op not configured' };
+                if (typeof cmd.agent !== 'string' || !cmd.agent || typeof cmd.sessionId !== 'string' || !cmd.sessionId) {
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing agent or sessionId' };
+                }
+                if (cmd.action !== undefined && !['clear', 'cancel', 'interrupt'].includes(cmd.action)) {
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'invalid queue action' };
+                }
+                return await this.queueOperationExecutor({
+                    agent: cmd.agent,
+                    action: cmd.action,
+                    messageId: typeof cmd.messageId === 'string' ? cmd.messageId : undefined,
+                    sessionKey: typeof cmd.sessionKey === 'string' ? cmd.sessionKey : undefined,
+                    sessionId: cmd.sessionId,
+                    delegationToken: typeof cmd.delegationToken === 'string' ? cmd.delegationToken : undefined,
+                    delegationCommandHash: typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined,
+                });
+            }
+            case 'status.auth': {
+                if (!this.statusAuthorizationExecutor)
+                    return { ok: false, code: 'NOT_CONFIGURED', error: 'status authorization not configured' };
+                if (typeof cmd.sessionId !== 'string' || !cmd.sessionId)
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing sessionId' };
+                return await this.statusAuthorizationExecutor({
+                    sessionId: cmd.sessionId,
+                    delegationToken: typeof cmd.delegationToken === 'string' ? cmd.delegationToken : undefined,
+                    delegationCommandHash: typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined,
+                });
+            }
+            case 'storage.auth': {
+                if (!this.storageAuthorizationExecutor)
+                    return { ok: false, code: 'NOT_CONFIGURED', error: 'storage authorization not configured' };
+                if (typeof cmd.sessionId !== 'string' || !cmd.sessionId || typeof cmd.aid !== 'string' || !cmd.aid || typeof cmd.operation !== 'string') {
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing sessionId, aid, or operation' };
+                }
+                if (!['storage.list', 'storage.quota', 'storage.upload', 'storage.download', 'storage.delete'].includes(cmd.operation)) {
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'invalid storage operation' };
+                }
+                return await this.storageAuthorizationExecutor({
+                    sessionId: cmd.sessionId,
+                    aid: cmd.aid,
+                    operation: cmd.operation,
+                    delegationToken: typeof cmd.delegationToken === 'string' ? cmd.delegationToken : undefined,
+                    delegationCommandHash: typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined,
+                });
+            }
             case 'aun-aid-stats-record-outbound': {
                 if (!this.aunAidStatsRecorder)
                     return { ok: false, error: 'recorder not configured' };
@@ -510,14 +644,17 @@ export class IpcServer {
                     }
                     : undefined;
                 try {
+                    const normalizedPayload = payload && Object.prototype.hasOwnProperty.call(payload, 'mentions')
+                        ? { ...payload, mentions: normalizeAunMentionEntries(payload.mentions) }
+                        : payload;
                     return await this.aunMsgSender({
                         aid: cmd.aid,
                         to: cmd.to,
                         scope: cmd.scope === 'group' ? 'group' : 'msg',
-                        payload,
+                        payload: normalizedPayload,
                         file,
-                        mentions: Array.isArray(cmd.mentions)
-                            ? cmd.mentions.filter((entry) => !!entry && typeof entry === 'object' && !Array.isArray(entry))
+                        mentions: Object.prototype.hasOwnProperty.call(cmd, 'mentions')
+                            ? normalizeAunMentionEntries(cmd.mentions)
                             : undefined,
                         encrypt: typeof cmd.encrypt === 'boolean' ? cmd.encrypt : undefined,
                         thread: typeof cmd.thread === 'string' ? cmd.thread : undefined,
@@ -530,7 +667,7 @@ export class IpcServer {
                     });
                 }
                 catch (e) {
-                    return { ok: false, error: e?.message || String(e) };
+                    return { ok: false, error: e?.message || String(e), code: e?.code };
                 }
             }
             case 'handoff-return': {
@@ -559,6 +696,8 @@ export class IpcServer {
                 return this.handoffStatusExecutor({
                     sessionId: typeof cmd.sessionId === 'string' ? cmd.sessionId : undefined,
                     handoffId: cmd.handoffId,
+                    delegationToken: typeof cmd.delegationToken === 'string' ? cmd.delegationToken : undefined,
+                    delegationCommandHash: typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined,
                 });
             }
             case 'handoff-list': {
@@ -578,6 +717,8 @@ export class IpcServer {
                     state: state,
                     filterSessionId: typeof cmd.filterSessionId === 'string' ? cmd.filterSessionId : undefined,
                     limit,
+                    delegationToken: typeof cmd.delegationToken === 'string' ? cmd.delegationToken : undefined,
+                    delegationCommandHash: typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined,
                 });
             }
             case 'handoff-trace': {
@@ -595,6 +736,8 @@ export class IpcServer {
                     agent: typeof cmd.agent === 'string' ? cmd.agent : undefined,
                     handoffId: cmd.handoffId,
                     limit,
+                    delegationToken: typeof cmd.delegationToken === 'string' ? cmd.delegationToken : undefined,
+                    delegationCommandHash: typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined,
                 });
             }
             case 'ctl': {
@@ -629,6 +772,54 @@ export class IpcServer {
                 }
                 return await this.contactOperationExecutor(argv, sessionId, delegationToken, typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined);
             }
+            case 'aid.op': {
+                if (!this.aidOperationExecutor)
+                    return { ok: false, code: 'NOT_CONFIGURED', error: 'aid.op not configured' };
+                const { argv, sessionId, delegationToken } = cmd;
+                if (!Array.isArray(argv) || argv.some(value => typeof value !== 'string') || !sessionId) {
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing argv or sessionId' };
+                }
+                if (delegationToken !== undefined && typeof delegationToken !== 'string') {
+                    return { ok: false, code: 'INVALID_DELEGATION', error: 'delegationToken must be a string' };
+                }
+                return await this.aidOperationExecutor(argv, sessionId, delegationToken, typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined);
+            }
+            case 'group.op': {
+                if (!this.groupOperationExecutor)
+                    return { ok: false, code: 'NOT_CONFIGURED', error: 'group.op not configured' };
+                const { argv, sessionId, delegationToken } = cmd;
+                if (!Array.isArray(argv) || argv.some(value => typeof value !== 'string') || !sessionId) {
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing argv or sessionId' };
+                }
+                if (delegationToken !== undefined && typeof delegationToken !== 'string') {
+                    return { ok: false, code: 'INVALID_DELEGATION', error: 'delegationToken must be a string' };
+                }
+                return await this.groupOperationExecutor(argv, sessionId, delegationToken, typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined);
+            }
+            case 'msg.op': {
+                if (!this.msgOperationExecutor)
+                    return { ok: false, code: 'NOT_CONFIGURED', error: 'msg.op not configured' };
+                const { argv, sessionId, delegationToken } = cmd;
+                if (!Array.isArray(argv) || argv.some(value => typeof value !== 'string') || !sessionId) {
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing argv or sessionId' };
+                }
+                if (delegationToken !== undefined && typeof delegationToken !== 'string') {
+                    return { ok: false, code: 'INVALID_DELEGATION', error: 'delegationToken must be a string' };
+                }
+                return await this.msgOperationExecutor(argv, sessionId, delegationToken, typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined);
+            }
+            case 'fs.op': {
+                if (!this.fsOperationExecutor)
+                    return { ok: false, code: 'NOT_CONFIGURED', error: 'fs.op not configured' };
+                const { argv, sessionId, delegationToken } = cmd;
+                if (!Array.isArray(argv) || argv.some(value => typeof value !== 'string') || !sessionId) {
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing argv or sessionId' };
+                }
+                if (delegationToken !== undefined && typeof delegationToken !== 'string') {
+                    return { ok: false, code: 'INVALID_DELEGATION', error: 'delegationToken must be a string' };
+                }
+                return await this.fsOperationExecutor(argv, sessionId, delegationToken, typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined);
+            }
             case 'trigger.list':
             case 'trigger.show':
             case 'trigger.history':
@@ -668,29 +859,43 @@ export class IpcServer {
                     return { ok: false, error: `Agent "${name}" found but info missing (race?)` };
                 return { ok: true, agent: info };
             }
+            case 'evolagent.bootstrapComplete': {
+                const aid = cmd.aid;
+                if (!aid || typeof aid !== 'string')
+                    return { ok: false, error: 'missing aid' };
+                if (!this.bootstrapCompleteExecutor)
+                    return { ok: false, error: 'bootstrap complete executor not configured' };
+                try {
+                    return await this.bootstrapCompleteExecutor(aid, {
+                        sessionId: typeof cmd.sessionId === 'string' ? cmd.sessionId : undefined,
+                        delegationToken: typeof cmd.delegationToken === 'string' ? cmd.delegationToken : undefined,
+                        delegationCommandHash: typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined,
+                        controlToken: typeof cmd.controlToken === 'string' ? cmd.controlToken : undefined,
+                    });
+                }
+                catch (e) {
+                    return { ok: false, error: e?.message || String(e) };
+                }
+            }
             case 'evolagent.reload': {
                 if (!this.agentRegistry)
                     return { ok: false, error: 'EvolAgentRegistry not available' };
                 const name = cmd.name;
                 if (!name || typeof name !== 'string')
                     return { ok: false, error: 'missing name' };
-                const hooks = globalThis.__evolcore_reloadHooks;
-                if (!hooks)
-                    return { ok: false, error: 'Reload hooks not initialized' };
+                if (!this.agentReloadExecutor)
+                    return { ok: false, error: 'Agent reload coordinator not initialized' };
                 try {
                     const a = this.agentRegistry.get(name);
                     if (!a)
                         return { ok: false, error: `Agent "${name}" not found` };
-                    if (!this.agentRegistry.reload)
-                        return { ok: false, error: 'EvolAgentRegistry.reload not available' };
-                    // 'kits' 组（manifest / fragment / schema / 角色模板）走 on-reload 策略，平时不查盘：
-                    // reload 是它唯一的刷新时机，必须先清再 reload，否则重载出来的 agent 仍用旧模板。
-                    const { invalidateKitCache } = await import('./eck/kit-renderer.js');
-                    invalidateKitCache();
-                    await this.agentRegistry.reload(name, hooks);
+                    await this.agentReloadExecutor(name, { force: cmd.force === true });
                     return { ok: true, result: `Agent "${name}" reloaded` };
                 }
                 catch (e) {
+                    if (e instanceof AgentReloadBusyError) {
+                        return { ok: false, code: e.code, busyCount: e.busyCount, error: e.message };
+                    }
                     return { ok: false, error: e?.message || String(e) };
                 }
             }
@@ -729,7 +934,11 @@ export class IpcServer {
                 if (!this.menuExecutor)
                     return { ok: false, error: 'menu.exec not configured' };
                 try {
-                    const response = await this.menuExecutor(cmd.payload, cmd.auth);
+                    const response = await this.menuExecutor(cmd.payload, {
+                        source: 'ecweb',
+                        actorAid: null,
+                        localDirect: true,
+                    });
                     return { ok: true, response };
                 }
                 catch (e) {
@@ -813,17 +1022,35 @@ export class IpcServer {
                 return { error: `unknown command: ${cmd.type}` };
         }
     }
+    hasValidControlToken(value) {
+        if (!this.controlToken || typeof value !== 'string')
+            return false;
+        const provided = Buffer.from(value);
+        return provided.length === this.controlToken.length
+            && crypto.timingSafeEqual(provided, this.controlToken);
+    }
 }
 /**
  * Query the running EvolCore daemon via Unix socket.
  * Returns null if the service is not running or the socket is unreachable.
  */
 export function ipcQuery(socketPath, cmd, timeoutMs = 3000) {
-    const delegationCommandHash = typeof cmd.delegationToken === 'string'
-        && typeof cmd.delegationCommandHash !== 'string'
+    let authenticatedCmd = cmd;
+    if (!process.env.EVOLCORE_SESSION_ID
+        && LOCAL_CONTROL_COMMANDS.has(cmd.type)
+        && typeof cmd.controlToken !== 'string') {
+        try {
+            const controlToken = fs.readFileSync(resolvePaths().controlToken, 'utf8').trim();
+            if (controlToken)
+                authenticatedCmd = { ...cmd, controlToken };
+        }
+        catch { }
+    }
+    const delegationCommandHash = typeof authenticatedCmd.delegationToken === 'string'
+        && typeof authenticatedCmd.delegationCommandHash !== 'string'
         ? hashCurrentDelegatedCommand()
         : undefined;
-    const request = delegationCommandHash ? { ...cmd, delegationCommandHash } : cmd;
+    const request = delegationCommandHash ? { ...authenticatedCmd, delegationCommandHash } : authenticatedCmd;
     return new Promise((resolve) => {
         const conn = net.connect(socketPath);
         let buf = '';

package/dist/response-system/coordinator.js

@@ -41,7 +41,8 @@ export class ResponseModeCoordinator {
             const { mode, modeConfig } = resolved;
             contextDeps.logger.debug('[ResponseSystem] resolveMode mode=' + mode.id + ' source=' + resolved.source + ' chatmode=' + (modeConfig.chatmode ?? 'none'));
             const context = this.contextBuilder.build(mode.id, { ...contextDeps, modeConfig });
-            return { mode, context, source: resolved.source };
+            const boundMode = mode.bind?.(context) ?? mode;
+            return { mode: boundMode, context, source: resolved.source };
         }
         catch (e) {
             contextDeps.logger.warn(`[Coordinator] resolveMode failed: ${e instanceof Error ? e.message : String(e)}`);
@@ -64,9 +65,10 @@ export class ResponseModeCoordinator {
                 ...deps.contextDeps,
                 modeConfig,
             });
-            await mode.initialize(context);
-            const decision = await mode.handleInbound(message);
-            return { modeId: mode.id, decision, mode, context };
+            const boundMode = mode.bind?.(context) ?? mode;
+            await boundMode.initialize(context);
+            const decision = await boundMode.handleInbound(message);
+            return { modeId: boundMode.id, decision, mode: boundMode, context };
         }
         catch (e) {
             deps.contextDeps.logger.warn(`[Coordinator] resolveInbound failed: ${e instanceof Error ? e.message : String(e)}`);

package/dist/response-system/engines/v1/proactive-flow.js

@@ -65,29 +65,37 @@ export const proactiveFlow = {
         const state = buildState(ctx.message, ctx.modeConfig ?? {});
         ctx.state.set(STATE_KEY, state);
     },
-    // ─── configureRun：policyHook 首工具表态 ───
+    // ─── configureRun：policyHook 只判定，不推进状态 ───
     configureRun(ctx) {
         const state = ctx.state.get(STATE_KEY);
-        if (!state || (!state.firstSendRequired && !state.toolReportRequired))
+        if (!state)
             return undefined;
         return {
             policyHook: (toolName, toolInput) => {
+                // Codex only invokes this hook for local tool paths. Hosted tools stay
+                // enabled and do not satisfy or clear the pending first-send gate.
                 const isSendCommand = ctx.isSendCommand(toolName, toolInput);
                 if (state.firstSendRequired && !state.firstToolDone) {
                     if (!isSendCommand) {
                         const cmdHint = state.chatType === 'group' ? 'ec group send' : 'ec msg send';
                         const target = state.chatType === 'group' ? '群里' : '对方';
-                        return { block: true, reason: `请先用 ${cmdHint} 向${target}说明你的意图，再执行其他工具` };
+                        return {
+                            block: true,
+                            policyCode: 'proactive_first_send_required',
+                            reason: `请先用 ${cmdHint} 向${target}说明你的意图，再执行其他工具`,
+                        };
                     }
-                    state.firstToolDone = true;
                 }
                 if (state.toolReportPending) {
                     if (!isSendCommand) {
                         const cmdHint = state.chatType === 'group' ? 'ec group send' : 'ec msg send';
                         const target = state.chatType === 'group' ? '群里' : '对方';
-                        return { block: true, reason: `工具调用已达到 ${state.toolCount} 次，请先用 ${cmdHint} 向${target}汇报当前情况和下一步意图，再执行其他工具` };
+                        return {
+                            block: true,
+                            policyCode: 'proactive_tool_report_required',
+                            reason: `工具调用已达到 ${state.toolCount} 次，请先用 ${cmdHint} 向${target}汇报当前情况和下一步意图，再执行其他工具`,
+                        };
                     }
-                    state.toolReportPending = false;
                 }
                 return undefined;
             },
@@ -96,7 +104,18 @@ export const proactiveFlow = {
     // ─── onToolUse：队列未读提醒 + 工具汇报提醒 ───
     onToolUse(ctx) {
         const state = ctx.state.get(STATE_KEY);
-        if (!state || !state.toolUseReminder)
+        if (!state)
+            return;
+        // PreToolUse 可能被工具子进程直接调用，因此审批阶段不能推进门禁状态。
+        // 只有 runner 发布真实工具事件后，精确匹配的发送命令才提交状态。
+        const isAllowedTool = ctx.isSendCommand(ctx.toolName, ctx.toolInput);
+        if (isAllowedTool) {
+            if (state.firstSendRequired && !state.firstToolDone)
+                state.firstToolDone = true;
+            if (state.toolReportPending)
+                state.toolReportPending = false;
+        }
+        if (!state.toolUseReminder)
             return;
         // 队列未读变化提醒
         const queueLen = ctx.getQueueLength();
@@ -110,7 +129,6 @@ export const proactiveFlow = {
             }
         }
         // 工具计数（排除表态命令白名单）
-        const isAllowedTool = ctx.isSendCommand(ctx.toolName, ctx.toolInput);
         if (state.toolReportRequired && !isAllowedTool)
             state.toolCount++;
         // 每 N 次工具调用警告

package/dist/response-system/modes/single-session/index.js

@@ -19,6 +19,7 @@ import { loadSchema } from '../../../config/schema-registry.js';
  * 解析后注入，见 implementation-plan.md §三；无 auto 值）。
  */
 export class SingleSessionMode {
+    context;
     id = 'single-session';
     displayName = '单会话模式';
     description = '单会话直接响应，按 chatMode 决定投递方式。';
@@ -26,8 +27,20 @@ export class SingleSessionMode {
     applicableScenes = ['private', 'group'];
     get configSchema() { return loadSchema('single-session').raw; }
     queue = new FIFOQueue();
-    context;
+    /**
+     * Registry 中的实例只承担模式定义的职责。每个实际会话都由 bind() 创建
+     * 独立实例，以免并发会话覆盖彼此的 modeConfig 和流程上下文。
+     */
+    constructor(context) {
+        this.context = context;
+    }
+    bind(context) {
+        return new SingleSessionMode(context);
+    }
     async initialize(context) {
+        if (this.context && this.context !== context) {
+            throw new Error('[single-session] bound instance initialized with a different context');
+        }
         this.context = context;
         context.logger.debug('[ResponseSystem] single-session initialized chatMode=' + this.chatMode());
     }

package/dist/response-system/selector.js

@@ -12,12 +12,13 @@ export class ResponseModeSelector {
         if (!mode) {
             throw new Error(`[ResponseModeSelector] mode not found: ${modeId}`);
         }
-        await mode.initialize(context);
-        context.logger.debug('[ResponseSystem] selector selected mode=' + mode.id + ' engine=' + (mode.engineType ?? 'v1'));
+        const boundMode = mode.bind?.(context) ?? mode;
+        await boundMode.initialize(context);
+        context.logger.debug('[ResponseSystem] selector selected mode=' + boundMode.id + ' engine=' + (boundMode.engineType ?? 'v1'));
         return {
-            id: mode.id,
-            engineType: mode.engineType ?? 'v1',
-            mode,
+            id: boundMode.id,
+            engineType: boundMode.engineType ?? 'v1',
+            mode: boundMode,
         };
     }
 }

package/dist/trigger/anomaly-store.js

@@ -251,7 +251,11 @@ function anomalyClassKey(anomaly) {
         anomaly.severity,
         anomaly.phase,
         anomaly.toolName,
+        anomaly.policyCode,
         anomaly.policy,
+        anomaly.agentAid,
+        anomaly.sessionId,
+        anomaly.permissionMode,
         anomaly.summary,
         anomaly.effect,
     ]);

package/dist/trigger/script-executor.js

@@ -52,6 +52,7 @@ export class TriggerScriptExecutor {
             const child = spawn(cmd, args, {
                 stdio: ['pipe', 'pipe', 'pipe'],
                 shell: false,
+                windowsHide: process.platform === 'win32',
                 env: process.env,
             });
             const abortHandler = () => {

package/dist/utils/aid-bind.js

@@ -45,7 +45,6 @@ export class BindService {
         }
         const ttlMs = clampTtl(req.ttlMs);
         const expiresAt = Date.now() + ttlMs;
-        const ownerMode = req.ownerMode === 'replace' ? 'replace' : 'append';
         const task = {
             taskId,
             bindType: req.bindType,
@@ -56,7 +55,6 @@ export class BindService {
             createdAt: Date.now(),
             expiresAt,
             status: 'pending',
-            ownerMode,
         };
         this.tasks.set(taskId, task);
         this.taskIdsByTokenHash.set(tokenHash, taskId);
@@ -209,9 +207,7 @@ export class BindService {
         if (task.bindType === 'daemon') {
             const cfg = loadDaemonConfig();
             const current = cfg.owners ?? [];
-            const owners = task.ownerMode === 'replace'
-                ? [ownerAid]
-                : [ownerAid, ...current.filter(o => o !== ownerAid)];
+            const owners = [ownerAid, ...current.filter(o => o !== ownerAid)];
             saveDaemonConfig({ ...cfg, $schema_version: cfg.$schema_version ?? 1, owners });
             this.opts.onDaemonOwnersUpdated?.(owners);
             return;
@@ -220,10 +216,9 @@ export class BindService {
         if (!agent)
             throw new Error(`agent not found: ${task.targetAid}`);
         const current = agent.owners ?? [];
-        const owners = task.ownerMode === 'replace'
-            ? [ownerAid]
-            : [ownerAid, ...current.filter(o => o !== ownerAid)];
+        const owners = [ownerAid, ...current.filter(o => o !== ownerAid)];
         saveAgent({ ...agent, owners });
+        this.opts.onAgentOwnerUpdated?.(task.targetAid, ownerAid);
     }
     cleanup() {
         const now = Date.now();