evolcore 0.0.21 → 0.0.23

package/dist/ipc.js

@@ -8,18 +8,22 @@ import path from 'path';
 import { logger } from './utils/logger.js';
 import { withMenuProcessingTime, logMenuRequestCompleted, logMenuRequestReceived } from './core/command/menu-protocol.js';
 import { fileCache } from './core/daemon-file-cache.js';
+import { DAEMON_RUNTIME_EPOCH_ENV } from './cli/task-context.js';
 import { HANDOFF_QUERY_MAX_LIMIT, HANDOFF_STATES } from './core/handoff/types.js';
 import { AgentReloadBusyError } from './core/agent-reload-coordinator.js';
-import { getWindowsInstanceSocketPathCandidates, resolvePaths } from './paths.js';
+import { getWindowsInstanceSocketPathCandidates, normalizeIpcEndpoint, resolvePaths } from './paths.js';
 import { getProcessStartTime, isSameOrOlderProcess } from './utils/process-introspect.js';
 import { classifyProcessTree, ProcessTreeSampler, readProcessMetrics } 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';
+import { remoteAccessService } from './core/auth/remote-access-store.js';
+import { setModelCatalogDaemonOwner } from './core/model/model-catalog.js';
 const isWindows = process.platform === 'win32';
-const isNamedPipe = (p) => isWindows && p.startsWith('\\\\.\\pipe\\');
+const isNamedPipe = (p) => isWindows && p.toLowerCase().startsWith('\\\\.\\pipe\\');
 const CPU_SAMPLE_INTERVAL_MS = 1000;
 const PROCESS_TREE_SAMPLE_INTERVAL_MS = 5000;
+const MONITOR_LEASE_TTL_MS = 15_000;
 const PROCESS_TREE_SAMPLE_WARN_MS = 250;
 const EVENT_LOOP_LAG_WARN_MS = 100;
 const SAMPLE_WARN_LOG_INTERVAL_MS = 60_000;
@@ -42,8 +46,15 @@ const LOCAL_CONTROL_COMMANDS = new Set([
     'evolagent.load',
     'evolagent.resync',
     'menu.exec',
+    'model.catalog',
     'monitor-snapshot',
+    'monitor-subscribe',
+    'monitor-unsubscribe',
     'shutdown',
+    'remote-auth.pair-code',
+    'remote-auth.issue-local',
+    'remote-auth.redeem',
+    'remote-auth.validate',
 ]);
 let ipcQuerySequence = 0;
 function ipcLogToken(value, fallback = 'unknown') {
@@ -80,9 +91,9 @@ export function summarizeMonitorAgents(agents, aids) {
     };
 }
 export class IpcServer {
-    socketPath;
     getStatus;
     commandExecutor;
+    socketPath;
     server = null;
     agentRegistry;
     agentApplicationService;
@@ -122,6 +133,8 @@ export class IpcServer {
     wecomContactBindExecutor;
     wechatContactBindExecutor;
     controlToken;
+    daemonRuntimeEpoch;
+    remoteAccessService = remoteAccessService;
     // CPU 占用追踪：IPC handler 是一次性同步调用，无法在响应里做 200ms 异步采样，
     // 故用后台 1s interval 累积 process.cpuUsage() 增量，handler 直接读最近值。
     // procCpuPercent = 本 daemon 进程占单核的百分比（可 >100% 仅当多核，已 clamp 到 100）；
@@ -138,6 +151,7 @@ export class IpcServer {
     processTreeWorkerRequestStartedAt = 0;
     processTreeWorkerRequestTimer = null;
     processTreeSamplingInFlight = false;
+    processTreeMonitorLeases = new Map();
     lastCpuTickMono = null;
     eventLoopLagMs = 0;
     maxEventLoopLagMs = 0;
@@ -155,9 +169,9 @@ export class IpcServer {
         lastError: null,
     };
     constructor(socketPath, getStatus, commandExecutor) {
-        this.socketPath = socketPath;
         this.getStatus = getStatus;
         this.commandExecutor = commandExecutor;
+        this.socketPath = normalizeIpcEndpoint(socketPath);
     }
     /** Inject EvolAgentRegistry for evolagent.* IPC handlers */
     setAgentRegistry(registry) {
@@ -171,6 +185,14 @@ export class IpcServer {
     setControlToken(token) {
         this.controlToken = Buffer.from(token);
     }
+    /** Use the daemon-owned remote access service for local consumers such as ECWeb. */
+    setRemoteAccessService(service) {
+        this.remoteAccessService = service;
+    }
+    /** Set the process-lifetime marker used to reject stale managed children. */
+    setDaemonRuntimeEpoch(epoch) {
+        this.daemonRuntimeEpoch = epoch;
+    }
     /** Inject menu.* executor (ECWeb Control proxies menu requests through this) */
     setMenuExecutor(executor) {
         this.menuExecutor = executor;
@@ -223,6 +245,87 @@ export class IpcServer {
     setAgentStatsProvider(provider) {
         this.agentStatsProvider = provider;
     }
+    /** Single current snapshot shared by ECWeb IPC and the daemon Menu view. */
+    getMonitorSnapshot(leaseId) {
+        if (typeof leaseId === 'string' && leaseId.trim())
+            this.refreshProcessTreeMonitor(leaseId);
+        else
+            this.sampleProcessTree();
+        const mem = process.memoryUsage();
+        const systemMemory = readSystemMemoryUsage();
+        const aids = this.aunAidProvider ? this.aunAidProvider() : [];
+        const aidStats = this.aunAidStatsProvider ? this.aunAidStatsProvider() : [];
+        const statsMap = new Map(aidStats.map(stat => [stat.aid, stat]));
+        const agentInfos = this.agentRegistry ? this.agentRegistry.list() : [];
+        const agentRuntimeStats = this.agentStatsProvider ? this.agentStatsProvider() : [];
+        const agentRuntimeStatsMap = new Map(agentRuntimeStats.map(stat => [stat.aid, stat]));
+        const aidStateMap = new Map(aids.map(state => [state.agentName || state.aid, state]));
+        const processTree = this.processTreeSnapshot;
+        const processTreeCpu = processTree?.processCount ? processTree.cpuPercent : this.cpuPercent;
+        const processTreeRss = processTree?.processCount ? processTree.rss : mem.rss;
+        const processTreeDetails = processTree ? {
+            ...processTree,
+            processes: classifyProcessTree(processTree.processes, process.pid, this.associatedProcessKinds),
+        } : {
+            rootPid: process.pid,
+            rootPids: [process.pid],
+            processCount: 1,
+            cpuPercent: Math.round(this.cpuPercent * 10) / 10,
+            rss: mem.rss,
+            processes: [{
+                    pid: process.pid,
+                    ppid: process.ppid,
+                    name: 'evolcore',
+                    cpuPercent: Math.round(this.cpuPercent * 10) / 10,
+                    rss: mem.rss,
+                    kind: 'daemon',
+                }],
+        };
+        return {
+            ok: true,
+            snapshot: {
+                ts: Date.now(),
+                uptimeMs: Math.round(process.uptime() * 1000),
+                cpuCount: os.cpus().length,
+                memory: {
+                    rss: processTreeRss,
+                    heapUsed: mem.heapUsed,
+                    heapTotal: mem.heapTotal,
+                    external: mem.external,
+                },
+                cpuPercent: processTreeCpu,
+                mainProcess: {
+                    pid: process.pid,
+                    cpuPercent: Math.round(this.cpuPercent * 10) / 10,
+                    memory: mem,
+                },
+                processTree: processTreeDetails,
+                sampling: {
+                    cpuIntervalMs: CPU_SAMPLE_INTERVAL_MS,
+                    processTreeIntervalMs: PROCESS_TREE_SAMPLE_INTERVAL_MS,
+                    eventLoopLagMs: this.eventLoopLagMs,
+                    maxEventLoopLagMs: this.maxEventLoopLagMs,
+                    processTree: { ...this.processTreeSampling },
+                },
+                system: {
+                    ...systemMemory,
+                    cpuPercent: Math.round(this.sysCpuPercent * 10) / 10,
+                    loadAvg: os.loadavg(),
+                },
+                stats: this.statsProvider ? this.statsProvider() : null,
+                agentSummary: summarizeMonitorAgents(agentInfos, aids),
+                agents: agentInfos.map(agent => ({
+                    aid: agent.aid,
+                    agentName: agent.name,
+                    status: agent.status,
+                    connectionStatus: aidStateMap.get(agent.aid)?.status ?? (agent.status === 'disabled' ? 'disabled' : 'unavailable'),
+                    online: agent.status !== 'disabled' && aidStateMap.get(agent.aid)?.status === 'connected',
+                    stats: statsMap.get(agent.aid) ?? null,
+                    runtimeStats: agentRuntimeStatsMap.get(agent.aid) ?? null,
+                })),
+            },
+        };
+    }
     /** Inject queue snapshot provider for queue-snapshot IPC handler (query mode) */
     setQueueSnapshotProvider(provider) {
         this.queueSnapshotProvider = provider;
@@ -296,11 +399,10 @@ export class IpcServer {
     setWechatContactBindExecutor(executor) {
         this.wechatContactBindExecutor = executor;
     }
-    /** Start the background CPU and process-tree sampling loops. Call after start(). */
+    /** Start the lightweight background CPU sampling loop. Call after start(). */
     startCpuTracking() {
         if (this.cpuTimer)
             return;
-        this.sampleProcessTree();
         this.lastCpuTickMono = performance.now();
         this.cpuTimer = setInterval(() => {
             const tickMono = performance.now();
@@ -342,17 +444,30 @@ export class IpcServer {
         }, CPU_SAMPLE_INTERVAL_MS);
         // Don't keep the event loop alive for sampling alone.
         this.cpuTimer.unref?.();
-        // Process enumeration is substantially more expensive on Windows than
-        // process.cpuUsage()/os.cpus(), so keep it at a lower refresh rate.
-        this.processTreeTimer = setInterval(() => this.sampleProcessTree(), PROCESS_TREE_SAMPLE_INTERVAL_MS);
-        this.processTreeTimer.unref?.();
     }
-    /** Stop the CPU and process-tree sampling loops. */
+    /** Stop all CPU and process-tree sampling loops. */
     stopCpuTracking() {
         if (this.cpuTimer) {
             clearInterval(this.cpuTimer);
             this.cpuTimer = null;
         }
+        this.processTreeMonitorLeases.clear();
+        this.stopProcessTreeTracking();
+        this.lastCpuTickMono = null;
+    }
+    startProcessTreeTracking() {
+        if (this.processTreeTimer)
+            return;
+        this.sampleProcessTree();
+        this.processTreeTimer = setInterval(() => {
+            this.pruneExpiredMonitorLeases();
+            if (this.processTreeMonitorLeases.size === 0)
+                return;
+            this.sampleProcessTree();
+        }, PROCESS_TREE_SAMPLE_INTERVAL_MS);
+        this.processTreeTimer.unref?.();
+    }
+    stopProcessTreeTracking() {
         if (this.processTreeTimer) {
             clearInterval(this.processTreeTimer);
             this.processTreeTimer = null;
@@ -372,7 +487,31 @@ export class IpcServer {
         this.processTreeWorker = null;
         if (worker)
             void worker.terminate();
-        this.lastCpuTickMono = null;
+        this.processTreeSnapshot = null;
+        this.associatedProcessKinds.clear();
+    }
+    acquireProcessTreeMonitor(leaseId) {
+        this.processTreeMonitorLeases.set(leaseId, Date.now() + MONITOR_LEASE_TTL_MS);
+        this.startProcessTreeTracking();
+    }
+    refreshProcessTreeMonitor(leaseId) {
+        if (typeof leaseId !== 'string' || !this.processTreeMonitorLeases.has(leaseId))
+            return;
+        this.processTreeMonitorLeases.set(leaseId, Date.now() + MONITOR_LEASE_TTL_MS);
+    }
+    releaseProcessTreeMonitor(leaseId) {
+        this.processTreeMonitorLeases.delete(leaseId);
+        if (this.processTreeMonitorLeases.size === 0)
+            this.stopProcessTreeTracking();
+    }
+    pruneExpiredMonitorLeases() {
+        const now = Date.now();
+        for (const [leaseId, expiresAt] of this.processTreeMonitorLeases) {
+            if (expiresAt <= now)
+                this.processTreeMonitorLeases.delete(leaseId);
+        }
+        if (this.processTreeMonitorLeases.size === 0)
+            this.stopProcessTreeTracking();
     }
     sampleProcessTree() {
         if (isWindows) {
@@ -577,6 +716,7 @@ export class IpcServer {
         return roots;
     }
     start() {
+        setModelCatalogDaemonOwner(true);
         if (this.server)
             return Promise.resolve();
         // Remove stale socket file (Unix only — named pipes auto-cleanup on process exit)
@@ -639,6 +779,7 @@ export class IpcServer {
         });
     }
     stop() {
+        setModelCatalogDaemonOwner(false);
         if (this.server) {
             this.server.close();
             this.server = null;
@@ -654,7 +795,31 @@ export class IpcServer {
         if (requiresLocalControlToken(cmd) && !this.hasValidControlToken(cmd.controlToken)) {
             return { ok: false, code: 'INVALID_CONTROL_TOKEN', error: 'valid local control token is required' };
         }
+        if (typeof cmd.sessionId === 'string' && cmd.sessionId
+            && typeof cmd.delegationToken === 'string' && cmd.delegationToken
+            && this.daemonRuntimeEpoch
+            && cmd.daemonRuntimeEpoch !== this.daemonRuntimeEpoch) {
+            logger.warn(`[IPC] stale delegation rejected: session=${ipcLogToken(cmd.sessionId)} type=${ipcLogToken(cmd.type)} cause=daemon_runtime_epoch_mismatch`);
+            return {
+                ok: false,
+                code: 'DAEMON_RESTARTED',
+                error: 'The task delegation token belongs to a previous daemon runtime; start a new task authorization and do not retry this command in the current task',
+            };
+        }
         switch (cmd.type) {
+            case 'model.catalog': {
+                if ((cmd.self !== undefined && typeof cmd.self !== 'string')
+                    || (cmd.baseagent !== undefined && !['claude', 'codex', 'ecagent', 'gemini'].includes(cmd.baseagent))) {
+                    return { ok: false, error: 'Invalid model catalog scope' };
+                }
+                try {
+                    const { getLocalCatalog } = await import('./core/model/model-catalog.js');
+                    return { ok: true, snapshot: await getLocalCatalog(cmd.self, cmd.baseagent, cmd.refresh === true) };
+                }
+                catch {
+                    return { ok: false, error: 'Unable to resolve model catalog configuration' };
+                }
+            }
             case 'status':
                 return this.getStatus();
             case 'codex-pre-tool-use': {
@@ -670,6 +835,7 @@ export class IpcServer {
                         threadId: cmd.threadId,
                         toolName: cmd.toolName,
                         toolInput: cmd.toolInput,
+                        callId: typeof cmd.callId === 'string' ? cmd.callId : undefined,
                         signal: requestSignal,
                     });
                 }
@@ -711,6 +877,19 @@ export class IpcServer {
                     ttlMs: cmd.ttlMs,
                 });
             }
+            case 'remote-auth.pair-code': {
+                const pair = this.remoteAccessService.getPairingCode(typeof cmd.authorizedBy === 'string' ? cmd.authorizedBy : undefined);
+                return { ok: true, ...pair };
+            }
+            case 'remote-auth.issue-local': {
+                return this.remoteAccessService.issueLocalToken(cmd.label);
+            }
+            case 'remote-auth.redeem': {
+                return this.remoteAccessService.redeemPairingCode(cmd.code, cmd.label, cmd.authorizedBy);
+            }
+            case 'remote-auth.validate': {
+                return { ok: true, ...this.remoteAccessService.validateToken(cmd.token) };
+            }
             case 'bind.status': {
                 if (!this.bindExecutor)
                     return { ok: false, error: 'bind executor not configured' };
@@ -1327,85 +1506,21 @@ export class IpcServer {
                     return { ok: false, error: e?.message ?? String(e) };
                 }
             }
-            case 'monitor-snapshot': {
-                // watch web Monitor 页用：进程级 + 系统级运行指标 + 全局 stats + per-agent 汇总。
-                const mem = process.memoryUsage();
-                const systemMemory = readSystemMemoryUsage();
-                const aids = this.aunAidProvider ? this.aunAidProvider() : [];
-                const aidStats = this.aunAidStatsProvider ? this.aunAidStatsProvider() : [];
-                const statsMap = new Map(aidStats.map((s) => [s.aid, s]));
-                const agentInfos = this.agentRegistry ? this.agentRegistry.list() : [];
-                const agentRuntimeStats = this.agentStatsProvider ? this.agentStatsProvider() : [];
-                const agentRuntimeStatsMap = new Map(agentRuntimeStats.map((s) => [s.aid, s]));
-                const aidStateMap = new Map(aids.map((state) => [state.agentName || state.aid, state]));
-                const agentSummary = summarizeMonitorAgents(agentInfos, aids);
-                const processTree = this.processTreeSnapshot;
-                const processTreeCpu = processTree?.processCount ? processTree.cpuPercent : this.cpuPercent;
-                const processTreeRss = processTree?.processCount ? processTree.rss : mem.rss;
-                const processTreeDetails = processTree ? {
-                    ...processTree,
-                    processes: classifyProcessTree(processTree.processes, process.pid, this.associatedProcessKinds),
-                } : {
-                    rootPid: process.pid,
-                    rootPids: [process.pid],
-                    processCount: 1,
-                    cpuPercent: Math.round(this.cpuPercent * 10) / 10,
-                    rss: mem.rss,
-                    processes: [{
-                            pid: process.pid,
-                            ppid: process.ppid,
-                            name: 'evolcore',
-                            cpuPercent: Math.round(this.cpuPercent * 10) / 10,
-                            rss: mem.rss,
-                            kind: 'daemon',
-                        }],
-                };
-                return {
-                    ok: true,
-                    snapshot: {
-                        ts: Date.now(),
-                        uptimeMs: Math.round(process.uptime() * 1000),
-                        cpuCount: os.cpus().length,
-                        // 进程级：daemon + 子进程 + 登记在册的关联进程树
-                        memory: {
-                            rss: processTreeRss,
-                            heapUsed: mem.heapUsed,
-                            heapTotal: mem.heapTotal,
-                            external: mem.external,
-                        },
-                        cpuPercent: processTreeCpu,
-                        mainProcess: {
-                            pid: process.pid,
-                            cpuPercent: Math.round(this.cpuPercent * 10) / 10,
-                            memory: mem,
-                        },
-                        processTree: processTreeDetails,
-                        sampling: {
-                            cpuIntervalMs: CPU_SAMPLE_INTERVAL_MS,
-                            processTreeIntervalMs: PROCESS_TREE_SAMPLE_INTERVAL_MS,
-                            eventLoopLagMs: this.eventLoopLagMs,
-                            maxEventLoopLagMs: this.maxEventLoopLagMs,
-                            processTree: { ...this.processTreeSampling },
-                        },
-                        // 系统级：整机
-                        system: {
-                            ...systemMemory,
-                            cpuPercent: Math.round(this.sysCpuPercent * 10) / 10,
-                            loadAvg: os.loadavg(), // [1m, 5m, 15m]（Windows 恒 0）
-                        },
-                        stats: this.statsProvider ? this.statsProvider() : null,
-                        agentSummary,
-                        agents: agentInfos.map((a) => ({
-                            aid: a.aid,
-                            agentName: a.name,
-                            status: a.status,
-                            connectionStatus: aidStateMap.get(a.aid)?.status ?? (a.status === 'disabled' ? 'disabled' : 'unavailable'),
-                            online: a.status !== 'disabled' && aidStateMap.get(a.aid)?.status === 'connected',
-                            stats: statsMap.get(a.aid) ?? null,
-                            runtimeStats: agentRuntimeStatsMap.get(a.aid) ?? null,
-                        })),
-                    },
-                };
+            case 'monitor-snapshot':
+                return this.getMonitorSnapshot(cmd.leaseId);
+            case 'monitor-subscribe': {
+                const leaseId = typeof cmd.leaseId === 'string' ? cmd.leaseId.trim() : '';
+                if (!leaseId || leaseId.length > 128)
+                    return { ok: false, error: 'invalid monitor lease id' };
+                this.acquireProcessTreeMonitor(leaseId);
+                return { ok: true, leaseTtlMs: MONITOR_LEASE_TTL_MS };
+            }
+            case 'monitor-unsubscribe': {
+                const leaseId = typeof cmd.leaseId === 'string' ? cmd.leaseId.trim() : '';
+                if (!leaseId || leaseId.length > 128)
+                    return { ok: false, error: 'invalid monitor lease id' };
+                this.releaseProcessTreeMonitor(leaseId);
+                return { ok: true };
             }
             default:
                 return { error: `unknown command: ${cmd.type}` };
@@ -1425,14 +1540,15 @@ export class IpcServer {
  */
 /** Pass `null` as timeoutMs to wait without a client-side deadline. */
 export function ipcQuery(socketPath, cmd, timeoutMs = 3000) {
-    let socketCandidates = [socketPath];
-    if (isNamedPipe(socketPath)) {
+    const endpoint = normalizeIpcEndpoint(socketPath);
+    let socketCandidates = [endpoint];
+    if (isNamedPipe(endpoint)) {
         const paths = resolvePaths();
-        if (socketPath === paths.socket)
+        if (endpoint === paths.socket)
             socketCandidates = getWindowsInstanceSocketPathCandidates(paths.root);
     }
     if (socketCandidates.length <= 1)
-        return ipcQueryOnce(socketPath, cmd, timeoutMs);
+        return ipcQueryOnce(endpoint, cmd, timeoutMs);
     return (async () => {
         const startedAt = Date.now();
         for (const candidate of socketCandidates) {
@@ -1464,7 +1580,13 @@ function ipcQueryOnce(socketPath, cmd, timeoutMs = 3000) {
         && typeof authenticatedCmd.delegationCommandHash !== 'string'
         ? hashCurrentDelegatedCommand()
         : undefined;
-    const request = delegationCommandHash ? { ...authenticatedCmd, delegationCommandHash } : authenticatedCmd;
+    const request = {
+        ...(delegationCommandHash ? { ...authenticatedCmd, delegationCommandHash } : authenticatedCmd),
+        ...(process.env[DAEMON_RUNTIME_EPOCH_ENV]
+            && typeof authenticatedCmd.delegationToken === 'string'
+            ? { daemonRuntimeEpoch: process.env[DAEMON_RUNTIME_EPOCH_ENV] }
+            : {}),
+    };
     return new Promise((resolve) => {
         const startedAtMono = performance.now();
         const queryId = nextIpcQueryId(request);

package/dist/paths.js

@@ -179,6 +179,24 @@ function windowsSocketPathForRoot(root) {
     const hash = crypto.createHash('sha1').update(root).digest('hex').slice(0, 12);
     return `\\\\.\\pipe\\${WINDOWS_PIPE_PREFIX}-${hash}`;
 }
+/**
+ * Normalize an IPC endpoint before it reaches node:net.
+ *
+ * Windows does not support Unix-domain socket files at ordinary filesystem
+ * paths. Callers that construct an ad-hoc `.sock` path (tests and embedded
+ * runtimes in particular) must therefore use the same deterministic named
+ * pipe on both the server and client sides. Existing named pipes and all
+ * non-Windows endpoints are preserved verbatim.
+ */
+export function normalizeIpcEndpoint(endpoint) {
+    // Windows object-manager paths are case-insensitive. Preserve an explicit
+    // named pipe verbatim even when a caller spells the namespace as `PIPE`.
+    if (!isWindows || endpoint.toLowerCase().startsWith('\\\\.\\pipe\\'))
+        return endpoint;
+    const normalized = path.win32.resolve(endpoint).toLowerCase();
+    const hash = crypto.createHash('sha1').update(normalized).digest('hex').slice(0, 20);
+    return `\\\\.\\pipe\\${WINDOWS_PIPE_PREFIX}-endpoint-${hash}`;
+}
 /**
  * Return the canonical and pre-normalization Windows daemon pipe names.
  *

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

@@ -197,6 +197,7 @@ export const proactiveFlow = {
                 const queueMsg = queueLen >= 5
                     ? `⚠️ 有 ${queueLen} 条消息未读，请尽快完成当前任务，或使用 ec ctl queue 读取后同步处理。`
                     : `⚠️ 有 ${queueLen} 条消息未读，可使用 ec ctl queue 读取。`;
+                ctx.recordReminder?.({ kind: 'queue_unread', text: queueMsg, queueLength: queueLen });
                 ctx.injectToModel(queueMsg);
             }
         }
@@ -208,13 +209,17 @@ export const proactiveFlow = {
             state.toolReportPending = true;
             const cmdHint = state.chatType === 'group' ? 'ec group send' : 'ec msg send';
             const target = state.chatType === 'group' ? '群里' : '对方';
-            ctx.injectToModel(`⚠️ 工具调用已达到 ${state.toolCount} 次，请立即用 ${cmdHint} 向${target}汇报当前情况和下一步意图。`);
+            const reportMsg = `⚠️ 工具调用已达到 ${state.toolCount} 次，请立即用 ${cmdHint} 向${target}汇报当前情况和下一步意图。`;
+            ctx.recordReminder?.({ kind: 'tool_report', text: reportMsg, toolCount: state.toolCount });
+            ctx.injectToModel(reportMsg);
         }
     },
     // ─── onToolResult：成功发送回执后解除门禁 ───
     onToolResult(ctx) {
         const state = ctx.state.get(STATE_KEY);
-        if (!state || !ctx.isSendCommand(ctx.toolName, ctx.toolInput))
+        if (!state)
+            return;
+        if (!ctx.isSendCommand(ctx.toolName, ctx.toolInput))
             return;
         if (!hasSuccessfulSendReceipt(ctx.result, ctx.isError || !!ctx.error))
             return;

package/dist/stats/price-resolver.js

@@ -5,6 +5,10 @@
 import { resolvePriceRow, BILLING_FNS } from './billing.js';
 import fs from 'fs';
 import path from 'path';
+/** Keep wire/log metadata readable while preserving full precision in storage. */
+export function roundCostForOutput(value) {
+    return Number.isFinite(value) ? Number(value.toFixed(4)) : value;
+}
 // 网关价格表缓存（从用户覆盖层 model-prices-gateway.jsonl 读取）
 let _gatewayPriceCache = null;
 let _gatewayPriceCacheTs = 0;

package/dist/trigger/feedback.js

@@ -251,12 +251,24 @@ export class TriggerFeedbackDispatcher {
                     };
                 }
                 if (event?.type === 'trigger:skipped') {
+                    const interruption = event.executionState === 'interrupted' && event.decisionSource === 'infrastructure'
+                        ? {
+                            reasonCode: event.reasonCode ?? event.reason,
+                            decisionSource: event.decisionSource,
+                            executionState: event.executionState,
+                            ...(event.generation !== undefined ? { generation: event.generation } : {}),
+                            ...(event.currentGeneration !== undefined ? { currentGeneration: event.currentGeneration } : {}),
+                        }
+                        : undefined;
                     return {
-                        status: 'failed',
+                        status: interruption ? 'skipped' : 'failed',
                         reason: event.reason,
+                        ...(interruption ? { interruption } : {}),
                         feedback,
                         effects: [this.inboundEffect('success', target, session.id, startedAt)],
-                        error: { code: event.reason || 'target_session_skipped', message: event.reason || 'target session skipped' },
+                        error: interruption
+                            ? null
+                            : { code: event.reason || 'target_session_skipped', message: event.reason || 'target session skipped' },
                     };
                 }
                 return {

package/dist/trigger/manager.js

@@ -92,7 +92,9 @@ export class TriggerDefinitionManager {
         assertExplicitAunDeliveryRoutes(updated);
         this.assertAgent(updated);
         if (existing.execution.baseagent !== updated.execution.baseagent) {
-            throw new Error('execution.baseagent is immutable; create a new Trigger to use another baseagent');
+            if (existing.execution.type !== 'trigger_session' || updated.execution.type !== 'trigger_session') {
+                throw new Error('execution.baseagent is only mutable between trigger_session Triggers');
+            }
         }
         updated.createdAt = existing.createdAt;
         updated.updatedAt = Date.now();