evolcore 0.0.11 → 0.0.12

package/dist/ipc.js

@@ -1,5 +1,6 @@
 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';
@@ -11,8 +12,26 @@ import { getProcessStartTime, isSameOrOlderProcess } from './utils/process-intro
 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');
@@ -39,10 +58,14 @@ export class IpcServer {
     agentStatsProvider;
     queueSnapshotProvider;
     queueActionExecutor;
+    queueOperationExecutor;
+    statusAuthorizationExecutor;
+    storageAuthorizationExecutor;
     triggerExecutor;
     bootstrapCompleteExecutor;
     agentReloadExecutor;
     taskRuntimeContextProvider;
+    codexPreToolUseExecutor;
     aunMsgSender;
     handoffReturnExecutor;
     handoffStatusExecutor;
@@ -51,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）；
@@ -78,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;
@@ -88,6 +120,18 @@ 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;
     }
@@ -119,6 +163,15 @@ 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;
@@ -131,6 +184,9 @@ export class IpcServer {
     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;
@@ -323,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': {
@@ -454,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' };
@@ -519,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,
@@ -539,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': {
@@ -568,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': {
@@ -587,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': {
@@ -604,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': {
@@ -638,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':
@@ -684,7 +866,12 @@ export class IpcServer {
                 if (!this.bootstrapCompleteExecutor)
                     return { ok: false, error: 'bootstrap complete executor not configured' };
                 try {
-                    return await this.bootstrapCompleteExecutor(aid);
+                    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) };
@@ -747,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) {
@@ -831,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/codex-app-server-registry.js

@@ -0,0 +1,90 @@
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths } from '../paths.js';
+import { getProcessStartTime } from './process-introspect.js';
+const CODEX_APP_SERVER_RECORD_PREFIX = 'codex-app-server-';
+const CODEX_APP_SERVER_RECORD_SUFFIX = '.json';
+function recordFilePath(pid) {
+    return path.join(resolvePaths().instanceDir, `${CODEX_APP_SERVER_RECORD_PREFIX}${pid}${CODEX_APP_SERVER_RECORD_SUFFIX}`);
+}
+function writeAtomic(filePath, data) {
+    const temporaryPath = `${filePath}.tmp`;
+    fs.writeFileSync(temporaryPath, data, { mode: 0o600 });
+    fs.renameSync(temporaryPath, filePath);
+}
+/** Register a Codex app-server child owned by this EvolCore runtime. */
+export function registerCodexAppServerProcess(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        throw new Error(`Invalid Codex app-server PID: ${pid}`);
+    const startedAt = getProcessStartTime(pid) ?? Date.now();
+    const filePath = recordFilePath(pid);
+    const record = {
+        owner: 'evolcore',
+        pid,
+        startedAt,
+        startedAtIso: new Date(startedAt).toISOString(),
+        parentPid: process.pid,
+    };
+    fs.mkdirSync(resolvePaths().instanceDir, { recursive: true });
+    writeAtomic(filePath, JSON.stringify(record, null, 2));
+    return filePath;
+}
+/** Remove a process record. Safe to call after a crash or a failed spawn. */
+export function unregisterCodexAppServerProcess(filePath) {
+    if (!filePath)
+        return;
+    try {
+        fs.unlinkSync(filePath);
+    }
+    catch { }
+    try {
+        fs.unlinkSync(`${filePath}.tmp`);
+    }
+    catch { }
+}
+/** Read only well-formed records; malformed records are removed as stale. */
+export function listCodexAppServerProcesses() {
+    const directory = resolvePaths().instanceDir;
+    let names;
+    try {
+        names = fs.readdirSync(directory);
+    }
+    catch {
+        return [];
+    }
+    const entries = [];
+    for (const name of names) {
+        if (!new RegExp(`^${CODEX_APP_SERVER_RECORD_PREFIX}\\d+\\${CODEX_APP_SERVER_RECORD_SUFFIX}$`).test(name))
+            continue;
+        const filePath = path.join(directory, name);
+        try {
+            const value = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+            const pid = value.pid;
+            const startedAt = value.startedAt;
+            const parentPid = value.parentPid;
+            if (value.owner !== 'evolcore'
+                || typeof pid !== 'number' || !Number.isInteger(pid) || pid <= 0
+                || typeof startedAt !== 'number' || !Number.isFinite(startedAt) || startedAt <= 0
+                || typeof parentPid !== 'number' || !Number.isInteger(parentPid) || parentPid <= 0) {
+                unregisterCodexAppServerProcess(filePath);
+                continue;
+            }
+            entries.push({
+                record: {
+                    owner: 'evolcore',
+                    pid,
+                    startedAt,
+                    startedAtIso: typeof value.startedAtIso === 'string'
+                        ? value.startedAtIso
+                        : new Date(startedAt).toISOString(),
+                    parentPid,
+                },
+                filePath,
+            });
+        }
+        catch {
+            unregisterCodexAppServerProcess(filePath);
+        }
+    }
+    return entries;
+}

package/dist/utils/codex-cli.js

@@ -35,5 +35,9 @@ export function execCodexCliSync(args, options) {
     const launchCommand = resolveCodexLaunchCommand(args, { commandPath });
     if (!launchCommand)
         throw new Error('Codex CLI not found');
-    return execFileSync(launchCommand.command, launchCommand.args, options);
+    return execFileSync(launchCommand.command, launchCommand.args, {
+        ...(options ?? {}),
+        // Keep the Windows console policy authoritative for every Codex CLI call.
+        windowsHide: process.platform === 'win32',
+    });
 }