evolcore 0.0.2 → 0.0.4

package/dist/utils/aid-bind.js

@@ -133,56 +133,70 @@ export class BindService {
             return fail('TASK_NOT_FOUND', 'binding task not found');
         if (payload.bindType !== task.bindType)
             return fail('BIND_TYPE_MISMATCH', 'bindType mismatch');
-        if (Date.now() > task.expiresAt) {
+        if (!fromAid)
+            return fail('INTERNAL_ERROR', 'missing AUN sender');
+        if (task.status === 'pending' && Date.now() > task.expiresAt) {
             task.status = 'expired';
             task.finishedAt ??= task.expiresAt;
             return fail('TASK_EXPIRED', 'binding task expired');
         }
-        if (task.status === 'bound')
+        if (task.status === 'bound') {
+            // The owner write and task transition necessarily happen before the caller
+            // can send bind.response. If that send fails, the App retries the same
+            // authenticated request. Replay the original success only to the AID that
+            // completed the bind; other senders must not receive daemonInfo.
+            if (task.boundAid === fromAid && task.boundResponse)
+                return task.boundResponse;
             return fail('ALREADY_BOUND', 'binding task already completed');
+        }
         if (task.status !== 'pending')
             return fail('TASK_NOT_FOUND', 'binding task is not pending');
         if (!timingSafeTokenEqual(payload.token, task.tokenHash)) {
             return fail('INVALID_TOKEN', 'invalid token');
         }
-        if (!fromAid)
-            return fail('INTERNAL_ERROR', 'missing AUN sender');
         try {
+            // Build and retain the exact response before committing the bind so a
+            // post-commit transport failure can be recovered by an idempotent retry.
+            const response = this.buildSuccessResponse(task);
             this.applyOwnerBinding(task, fromAid);
             task.status = 'bound';
             task.boundAid = fromAid;
             task.boundName = payload.clientName;
+            task.boundResponse = response;
             task.finishedAt = Date.now();
-            const details = task.bindType === 'agent' ? this.buildAgentBindDetails(task) : null;
-            return {
-                type: 'bind.response',
-                bindType: task.bindType,
-                success: true,
-                daemonInfo: {
-                    daemonAid: task.receiverAid,
-                    ...(task.bindType === 'agent' ? { agentAid: task.targetAid } : {}),
-                    bindType: task.bindType,
-                    ...(task.bindType === 'daemon'
-                        ? {
-                            version: readEvolcoreVersion(),
-                            platform: getPlatform(),
-                            uptime: this.opts.getUptimeSeconds(),
-                            baseagents: this.opts.getAvailableBaseagents(),
-                        }
-                        : {
-                            active_baseagent: details.baseagent.active_baseagent,
-                            model: details.baseagent.model,
-                            effort: details.baseagent.effort,
-                            channels: details.channels,
-                            agentName: task.agentName,
-                        }),
-                },
-            };
+            return response;
         }
         catch (e) {
             return fail('INTERNAL_ERROR', e?.message || String(e));
         }
     }
+    buildSuccessResponse(task) {
+        const details = task.bindType === 'agent' ? this.buildAgentBindDetails(task) : null;
+        return {
+            type: 'bind.response',
+            bindType: task.bindType,
+            success: true,
+            daemonInfo: {
+                daemonAid: task.receiverAid,
+                ...(task.bindType === 'agent' ? { agentAid: task.targetAid } : {}),
+                bindType: task.bindType,
+                ...(task.bindType === 'daemon'
+                    ? {
+                        version: readEvolcoreVersion(),
+                        platform: getPlatform(),
+                        uptime: this.opts.getUptimeSeconds(),
+                        baseagents: this.opts.getAvailableBaseagents(),
+                    }
+                    : {
+                        active_baseagent: details.baseagent.active_baseagent,
+                        model: details.baseagent.model,
+                        effort: details.baseagent.effort,
+                        channels: details.channels,
+                        agentName: task.agentName,
+                    }),
+            },
+        };
+    }
     buildAgentBindDetails(task) {
         const agent = loadAgent(task.targetAid);
         const config = resolveEffective({ self: task.targetAid }, { expand: true });

package/dist/utils/error-dict.json

@@ -56,6 +56,13 @@
       "type": "api_error",
       "message": "⚠️ 当前算力池切换中，请稍后重试"
     },
+    {
+      "id": "retry-attempt-stalled",
+      "match": "retry_attempt_stalled",
+      "action": "retry",
+      "type": "api_error",
+      "message": "⚠️ API 重试调用长时间无响应"
+    },
     {
       "id": "selected-model-at-capacity",
       "match": "selected model is at capacity",

package/dist/utils/evolcore-version.js

@@ -0,0 +1,21 @@
+import fs from 'fs';
+import path from 'path';
+import { getPackageRoot } from '../paths.js';
+let cachedVersion;
+export function readInstalledEvolcoreVersion() {
+    if (cachedVersion !== undefined)
+        return cachedVersion;
+    let version;
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(getPackageRoot(), 'package.json'), 'utf-8'));
+        version = typeof pkg.version === 'string' && pkg.version ? pkg.version : 'unknown';
+    }
+    catch {
+        version = 'unknown';
+    }
+    cachedVersion = version;
+    return version;
+}
+export function _resetInstalledEvolcoreVersionForTests() {
+    cachedVersion = undefined;
+}

package/dist/utils/instance-registry.js

@@ -14,6 +14,7 @@ import { spawnSync } from 'child_process';
 import { resolvePaths } from '../paths.js';
 import { isProcessRunning, killProcess, isWindows, findProcesses } from './cross-platform.js';
 import { getProcessStartTime, startTimeMatches } from './process-introspect.js';
+import { isConfirmedLeakedTestDaemon, runtimeHomeFromEnv } from './restart-safety.js';
 // ── Helpers ──
 function instanceDir() {
     return resolvePaths().instanceDir;
@@ -339,10 +340,11 @@ function killPid(pid) {
  * 用途：检测跨 HOME 残留的 evolcore 主进程（例如测试套件 spawn 后未清理、
  * 旧版本 pidfile 模式遗留等），由 cmdStart/cmdRestart 在启动前提示用户。
  *
- * Linux 下额外读取 /proc/<pid>/environ 提取 EVOLCORE_HOME 用于展示。
+ * Linux 下额外读取 /proc/<pid>/environ 提取 EVOLCORE_HOME，
+ * 并对 Vitest 泄漏的 restart-monitor daemon 做严格标记。
  * Windows / macOS 取不到环境变量时 evolcoreHome 为 null。
  *
- * 不会主动 kill——清理由调用方决定（cmdRestart --kill-orphans 才执行）。
+ * 不会主动 kill——清理由调用方决定。
  */
 export function findOrphanProcesses() {
     // 1. 已登记 PID（自己 HOME 下的 main + 自己进程）
@@ -367,10 +369,12 @@ export function findOrphanProcesses() {
         // 三次验证：排除 ecweb（/ecweb/dist/index.js）
         if (/[\\/]ecweb[\\/]dist[\\/]index\.js/.test(cmdline))
             continue;
+        const processEnv = readProcessEnvironment(pid);
         orphans.push({
             pid,
-            evolcoreHome: readEvolcoreHome(pid),
+            evolcoreHome: processEnv ? runtimeHomeFromEnv(processEnv) : null,
             cmdline,
+            confirmedTestDaemon: processEnv ? isConfirmedLeakedTestDaemon(processEnv) : false,
         });
     }
     return orphans;
@@ -418,16 +422,19 @@ function readCmdline(pid) {
         }
     }
 }
-function readEvolcoreHome(pid) {
+function readProcessEnvironment(pid) {
     // Linux: /proc/<pid>/environ
     if (!isWindows && process.platform !== 'darwin') {
         try {
             const env = fs.readFileSync(`/proc/${pid}/environ`, 'utf-8');
+            const result = {};
             for (const entry of env.split('\0')) {
-                if (entry.startsWith('EVOLCORE_HOME='))
-                    return entry.slice('EVOLCORE_HOME='.length);
+                const separator = entry.indexOf('=');
+                if (separator <= 0)
+                    continue;
+                result[entry.slice(0, separator)] = entry.slice(separator + 1);
             }
-            return null;
+            return result;
         }
         catch {
             return null;

package/dist/utils/log-writer.js

@@ -24,6 +24,52 @@ import path from 'path';
 import { clearInterval as clearNativeInterval, clearTimeout as clearNativeTimeout, setInterval as setNativeInterval, setTimeout as setNativeTimeout, } from 'node:timers';
 const HOUR_MS = 60 * 60 * 1000;
 const DAY_MS = 24 * HOUR_MS;
+/**
+ * Rotate the daemon's redirected stdout before a launcher opens it for append.
+ * stdout is owned by the launcher rather than LogWriter, so both start and
+ * restart paths must call this after the previous daemon has exited.
+ */
+export function rotateStdoutLog(logDir, options = {}) {
+    const maxSize = options.maxSize ?? 10 * 1024 * 1024;
+    const retentionMs = options.retentionMs ?? 7 * DAY_MS;
+    const now = options.now ?? Date.now();
+    const stdoutLog = path.join(logDir, 'stdout.log');
+    let rotatedPath = null;
+    try {
+        if (fs.statSync(stdoutLog).size > maxSize) {
+            const timestamp = new Date(now).toISOString().replace(/[:.]/g, '').slice(0, 15);
+            const baseArchive = `${stdoutLog}.${timestamp}`;
+            let archive = baseArchive;
+            let suffix = 1;
+            while (fs.existsSync(archive))
+                archive = `${baseArchive}.${suffix++}`;
+            fs.renameSync(stdoutLog, archive);
+            rotatedPath = archive;
+        }
+    }
+    catch {
+        // Missing/unreadable stdout must not prevent the daemon from starting.
+    }
+    const removedArchives = [];
+    const cutoff = now - retentionMs;
+    try {
+        for (const name of fs.readdirSync(logDir)) {
+            if (!name.startsWith('stdout.log.'))
+                continue;
+            const full = path.join(logDir, name);
+            try {
+                const stat = fs.lstatSync(full);
+                if (stat.isSymbolicLink() || stat.mtimeMs < cutoff) {
+                    fs.unlinkSync(full);
+                    removedArchives.push(full);
+                }
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return { rotatedPath, removedArchives };
+}
 export class LogWriter {
     baseName;
     logDir;

package/dist/utils/logger.js

@@ -51,8 +51,8 @@ function log(level, ...args) {
     getWriters().main.write(msg);
 }
 /**
- * 设置日志级别（config 加载后调用，覆盖环境变量默认值）
- * 优先级：config.debug.logLevel → LOG_LEVEL 环境变量 → 'INFO'
+ * 设置日志级别（daemon.json 加载后调用，覆盖环境变量默认值）
+ * 优先级：daemon.json debug.logLevel → LOG_LEVEL 环境变量 → 'INFO'
  */
 export function setLogLevel(level) {
     const upper = level.toUpperCase();

package/dist/utils/media-cache.js

@@ -183,7 +183,10 @@ export async function safeFetch(url, opts) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeout);
     try {
-        const res = await fetch(url, { signal: controller.signal });
+        const res = await fetch(url, {
+            signal: controller.signal,
+            redirect: opts?.rejectRedirects ? 'error' : 'follow',
+        });
         if (!res.ok)
             throw new Error(`Download failed: ${res.status} ${res.statusText}`);
         // 检查 Content-Length（如果可用）

package/dist/utils/model-prices.jsonl

@@ -3,9 +3,12 @@
 {"model":"claude-opus-4-6","effective_from":0,"billing_fn":"per_token_v1","currency":"USD","price_input":15,"price_output":75,"price_cache_creation":18.75,"price_cache_read":1.5}
 {"model":"claude-sonnet-4-6","effective_from":0,"billing_fn":"per_token_v1","currency":"USD","price_input":3,"price_output":15,"price_cache_creation":3.75,"price_cache_read":0.3}
 {"model":"claude-haiku-4-5-20251001","effective_from":0,"billing_fn":"per_token_v1","currency":"USD","price_input":0.8,"price_output":4,"price_cache_creation":1,"price_cache_read":0.08}
-{"model":"gpt-5.5","effective_from":0,"billing_fn":"per_token_v1","currency":"USD","price_input":2,"price_output":10,"price_cache_creation":0,"price_cache_read":0}
-{"model":"gpt-5.4","effective_from":0,"billing_fn":"per_token_v1","currency":"USD","price_input":2,"price_output":10,"price_cache_creation":0,"price_cache_read":0}
-{"model":"gpt-5.3-codex","effective_from":0,"billing_fn":"per_token_v1","currency":"USD","price_input":2,"price_output":10,"price_cache_creation":0,"price_cache_read":0}
+{"model":"gpt-5.6-sol","effective_from":0,"billing_fn":"per_token_v1","currency":"USD","price_input":5,"price_output":30,"price_cache_creation":6.25,"price_cache_read":0.5,"tiers":[{"up_to_input_tokens":272000,"price_input":5,"price_output":30,"price_cache_creation":6.25,"price_cache_read":0.5},{"up_to_input_tokens":null,"price_input":10,"price_output":45,"price_cache_creation":12.5,"price_cache_read":1}]}
+{"model":"gpt-5.6-terra","effective_from":0,"billing_fn":"per_token_v1","currency":"USD","price_input":2.5,"price_output":15,"price_cache_creation":3.125,"price_cache_read":0.25,"tiers":[{"up_to_input_tokens":272000,"price_input":2.5,"price_output":15,"price_cache_creation":3.125,"price_cache_read":0.25},{"up_to_input_tokens":null,"price_input":5,"price_output":22.5,"price_cache_creation":6.25,"price_cache_read":0.5}]}
+{"model":"gpt-5.6-luna","effective_from":0,"billing_fn":"per_token_v1","currency":"USD","price_input":1,"price_output":6,"price_cache_creation":1.25,"price_cache_read":0.1,"tiers":[{"up_to_input_tokens":272000,"price_input":1,"price_output":6,"price_cache_creation":1.25,"price_cache_read":0.1},{"up_to_input_tokens":null,"price_input":2,"price_output":9,"price_cache_creation":2.5,"price_cache_read":0.2}]}
+{"model":"gpt-5.5","effective_from":0,"billing_fn":"per_token_v1","currency":"USD","price_input":5,"price_output":30,"price_cache_creation":0,"price_cache_read":0.5,"tiers":[{"up_to_input_tokens":272000,"price_input":5,"price_output":30,"price_cache_creation":0,"price_cache_read":0.5},{"up_to_input_tokens":null,"price_input":10,"price_output":45,"price_cache_creation":0,"price_cache_read":1}]}
+{"model":"gpt-5.4","effective_from":0,"billing_fn":"per_token_v1","currency":"USD","price_input":2.5,"price_output":15,"price_cache_creation":0,"price_cache_read":0.25,"tiers":[{"up_to_input_tokens":272000,"price_input":2.5,"price_output":15,"price_cache_creation":0,"price_cache_read":0.25},{"up_to_input_tokens":null,"price_input":5,"price_output":22.5,"price_cache_creation":0,"price_cache_read":0.5}]}
+{"model":"gpt-5.3-codex","effective_from":0,"billing_fn":"per_token_v1","currency":"USD","price_input":1.75,"price_output":14,"price_cache_creation":0,"price_cache_read":0.175}
 {"model":"deepseek-v4-pro","effective_from":0,"billing_fn":"per_token_deepseek_v1","currency":"CNY","price_cache_hit":0.5,"price_cache_miss":2,"price_output":8}
 {"model":"deepseek-v4-flash","effective_from":0,"billing_fn":"per_token_deepseek_v1","currency":"CNY","price_cache_hit":0.1,"price_cache_miss":0.5,"price_output":2}
 {"model":"deepseek-v3.2","effective_from":0,"billing_fn":"per_token_deepseek_v1","currency":"CNY","price_cache_hit":0.5,"price_cache_miss":2,"price_output":8}

package/dist/utils/restart-safety.js

@@ -0,0 +1,31 @@
+const REAL_RESTART_TEST_OVERRIDE = 'EVOLCORE_ALLOW_REAL_RESTART_IN_TEST';
+export function isRestartTestRuntime(env = process.env) {
+    return env.VITEST === 'true'
+        || env.EVOLCORE_TEST === '1';
+}
+/**
+ * Unit tests must never detach a real restart-monitor/daemon pair by accident.
+ * Dedicated process-level integration tests can opt in explicitly.
+ */
+export function shouldSuppressRealRestart(env = process.env) {
+    return isRestartTestRuntime(env) && env[REAL_RESTART_TEST_OVERRIDE] !== '1';
+}
+export function runtimeHomeFromEnv(env) {
+    return env.EVOLCORE_HOME || null;
+}
+/**
+ * Strict classifier used before automatically killing leaked test daemons.
+ * All markers must agree so a legitimate secondary runtime is never mistaken
+ * for a disposable test process.
+ */
+export function isConfirmedLeakedTestDaemon(env) {
+    const home = runtimeHomeFromEnv(env);
+    if (!home || !/[\\/]evolcore-test-[^\\/]+$/.test(home))
+        return false;
+    const launchedBy = env.EVOLCORE_LAUNCHED_BY;
+    const testRuntime = env.VITEST === 'true'
+        || env.EVOLCORE_TEST === '1';
+    return testRuntime
+        && env.NODE_ENV === 'test'
+        && launchedBy === 'restart-monitor';
+}

package/dist/utils/stable-semver.js

@@ -0,0 +1,21 @@
+const STABLE_SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+export function parseStableSemver(value) {
+    if (typeof value !== 'string')
+        return null;
+    const match = STABLE_SEMVER.exec(value);
+    if (!match)
+        return null;
+    const parsed = [Number(match[1]), Number(match[2]), Number(match[3])];
+    if (parsed.some(part => !Number.isSafeInteger(part)))
+        return null;
+    return parsed;
+}
+export function compareStableSemver(left, right) {
+    for (let index = 0; index < 3; index += 1) {
+        if (left[index] < right[index])
+            return -1;
+        if (left[index] > right[index])
+            return 1;
+    }
+    return 0;
+}

package/dist/utils/stats.js

@@ -1,3 +1,4 @@
+import { formatPeerKey } from '../core/relation/peer-identity.js';
 export class StatsCollector {
     events = [];
     recentErrors = [];
@@ -136,6 +137,7 @@ export class StatsCollector {
 }
 export class AidStatsCollector {
     entries = new Map();
+    routePeers = new Map();
     queueStatsProvider;
     /** sessionId → 当前正在跑该 session 的 agent，task:started 写入，task:completed/error 清除 */
     sessionToAgent = new Map();
@@ -233,10 +235,12 @@ export class AidStatsCollector {
                 lastReceivedFrom: null,
                 lastReceivedEncrypt: null,
                 lastReceivedChatmode: null,
+                lastReceivedChannel: null,
                 lastSentText: null,
                 lastSentTo: null,
                 lastSentEncrypt: null,
                 lastSentChatmode: null,
+                lastSentChannel: null,
                 lastReceivedKind: null,
                 lastSentKind: null,
                 uniquePeers: new Set(),
@@ -256,6 +260,9 @@ export class AidStatsCollector {
         }
         return entry;
     }
+    routePeerKey(aid, channel, routeId) {
+        return `${aid}\u001f${channel}\u001f${routeId}`;
+    }
     onTaskStart(aid, encrypt, chatmode) {
         const entry = this.getOrCreate(aid);
         entry.currentTaskStartAt = Date.now();
@@ -298,25 +305,31 @@ export class AidStatsCollector {
         const entry = this.getOrCreate(aid);
         entry.selfName = name;
     }
-    recordInbound(aid, fromPeer, byteLength, text, isSystem = false, encrypt, chatmode, kind = 'send') {
+    recordInbound(aid, fromPeer, byteLength, text, isSystem = false, encrypt, chatmode, kind = 'send', ctx) {
         const entry = this.getOrCreate(aid);
+        const channel = ctx?.channelType || 'aun';
+        const peerLabel = ctx?.peerLabel || fromPeer;
+        if (ctx?.routeId && fromPeer) {
+            this.routePeers.set(this.routePeerKey(aid, channel, ctx.routeId), { peerId: fromPeer, peerLabel });
+        }
         if (isSystem) {
             entry.systemReceived++;
         }
         else {
             entry.messagesReceived++;
             entry.lastReceivedAt = Date.now();
-            entry.lastReceivedFrom = fromPeer;
+            entry.lastReceivedFrom = peerLabel;
             if (text)
                 entry.lastReceivedText = text.length > 100 ? text.slice(0, 100) + '…' : text;
             if (encrypt != null)
                 entry.lastReceivedEncrypt = encrypt;
             if (chatmode)
                 entry.lastReceivedChatmode = chatmode;
+            entry.lastReceivedChannel = channel;
             entry.lastReceivedKind = kind;
             // ring buffer：最近 10 轮
             if (text) {
-                entry.recentMessages.unshift({ dir: 'in', peer: fromPeer, text: text.slice(0, 100), ts: Date.now(), kind, encrypt: encrypt ?? null, chatmode: chatmode ?? null });
+                entry.recentMessages.unshift({ dir: 'in', peer: peerLabel, text: text.slice(0, 100), ts: Date.now(), kind, encrypt: encrypt ?? null, chatmode: chatmode ?? null, channel });
                 if (entry.recentMessages.length > 10)
                     entry.recentMessages.pop();
             }
@@ -325,30 +338,39 @@ export class AidStatsCollector {
         entry.uniquePeers.add(fromPeer);
         // 持久化
         this.onMessage?.({
-            ts: Date.now(), agent_aid: aid, peer_key: `aun#${fromPeer}`,
+            ts: Date.now(), agent_aid: aid, peer_key: formatPeerKey(channel, fromPeer),
             direction: 'in', msg_type: isSystem ? 'system' : 'private',
             bytes: byteLength, encrypted: encrypt, chatmode,
         });
     }
-    recordOutbound(aid, toPeer, byteLength, text, isSystem = false, encrypt, chatmode, kind = 'send') {
+    recordOutbound(aid, toPeer, byteLength, text, isSystem = false, encrypt, chatmode, kind = 'send', ctx) {
         const entry = this.getOrCreate(aid);
+        const channel = ctx?.channelType || 'aun';
+        const routePeer = ctx?.routeId
+            ? this.routePeers.get(this.routePeerKey(aid, channel, ctx.routeId))
+            : undefined;
+        const stablePeer = routePeer?.peerId || toPeer;
+        const peerLabel = ctx?.peerLabel && ctx.peerLabel !== toPeer
+            ? ctx.peerLabel
+            : routePeer?.peerLabel || ctx?.peerLabel || toPeer;
         if (isSystem) {
             entry.systemSent++;
         }
         else {
             entry.messagesSent++;
             entry.lastSentAt = Date.now();
-            entry.lastSentTo = toPeer;
+            entry.lastSentTo = peerLabel;
             if (text)
                 entry.lastSentText = text.length > 100 ? text.slice(0, 100) + '…' : text;
             if (encrypt != null)
                 entry.lastSentEncrypt = encrypt;
             if (chatmode)
                 entry.lastSentChatmode = chatmode;
+            entry.lastSentChannel = channel;
             entry.lastSentKind = kind;
             // ring buffer：最近 10 轮
             if (text) {
-                entry.recentMessages.unshift({ dir: 'out', peer: toPeer, text: text.slice(0, 100), ts: Date.now(), kind, encrypt: encrypt ?? null, chatmode: chatmode ?? null });
+                entry.recentMessages.unshift({ dir: 'out', peer: peerLabel, text: text.slice(0, 100), ts: Date.now(), kind, encrypt: encrypt ?? null, chatmode: chatmode ?? null, channel });
                 if (entry.recentMessages.length > 10)
                     entry.recentMessages.pop();
             }
@@ -362,10 +384,10 @@ export class AidStatsCollector {
             }
         }
         entry.bytesSent += byteLength;
-        entry.uniquePeers.add(toPeer);
+        entry.uniquePeers.add(stablePeer);
         // 持久化
         this.onMessage?.({
-            ts: Date.now(), agent_aid: aid, peer_key: `aun#${toPeer}`,
+            ts: Date.now(), agent_aid: aid, peer_key: formatPeerKey(channel, stablePeer),
             direction: 'out', msg_type: isSystem ? 'system' : 'private',
             bytes: byteLength, encrypted: encrypt, chatmode,
         });
@@ -391,10 +413,12 @@ export class AidStatsCollector {
                 lastReceivedFrom: entry.lastReceivedFrom,
                 lastReceivedEncrypt: entry.lastReceivedEncrypt,
                 lastReceivedChatmode: entry.lastReceivedChatmode,
+                lastReceivedChannel: entry.lastReceivedChannel,
                 lastSentText: entry.lastSentText,
                 lastSentTo: entry.lastSentTo,
                 lastSentEncrypt: entry.lastSentEncrypt,
                 lastSentChatmode: entry.lastSentChatmode,
+                lastSentChannel: entry.lastSentChannel,
                 lastReceivedKind: entry.lastReceivedKind,
                 lastSentKind: entry.lastSentKind,
                 uniquePeerCount: entry.uniquePeers.size,

package/dist/utils/system-memory.js

@@ -0,0 +1,62 @@
+import fs from 'fs';
+import os from 'os';
+function readNumber(filePath) {
+    try {
+        const value = Number(fs.readFileSync(filePath, 'utf8').trim());
+        return Number.isFinite(value) && value >= 0 ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function parseCgroupV2MemoryStat(input) {
+    const values = new Map();
+    for (const line of input.split('\n')) {
+        const [key, raw] = line.trim().split(/\s+/, 2);
+        const value = Number(raw);
+        if (key && Number.isFinite(value) && value >= 0)
+            values.set(key, value);
+    }
+    return values;
+}
+/**
+ * System memory for the current container/host namespace.
+ *
+ * Linux cgroup v2 uses memory.current - memory.stat:file so the value matches
+ * common host/container dashboards: anonymous + kernel memory, excluding
+ * reclaimable filesystem page cache. Other environments fall back to the
+ * portable total - available calculation exposed by Node.js.
+ */
+export function readSystemMemoryUsage(cgroupRoot = '/sys/fs/cgroup') {
+    const memTotal = os.totalmem();
+    const memAvailable = os.freemem();
+    if (process.platform === 'linux') {
+        const current = readNumber(`${cgroupRoot}/memory.current`);
+        if (current !== null) {
+            try {
+                const stat = parseCgroupV2MemoryStat(fs.readFileSync(`${cgroupRoot}/memory.stat`, 'utf8'));
+                const fileCache = stat.get('file');
+                if (fileCache !== undefined) {
+                    const memUsed = Math.max(0, current - fileCache);
+                    return {
+                        memTotal,
+                        memUsed,
+                        memFree: Math.max(0, memTotal - memUsed),
+                        memAvailable,
+                        memorySource: 'cgroup-v2-current-minus-file',
+                        cgroupCurrent: current,
+                        fileCache,
+                    };
+                }
+            }
+            catch { /* fall through to portable OS metrics */ }
+        }
+    }
+    return {
+        memTotal,
+        memUsed: Math.max(0, memTotal - memAvailable),
+        memFree: memAvailable,
+        memAvailable,
+        memorySource: 'os-total-minus-available',
+    };
+}

package/kits/docs/INDEX.md

@@ -25,6 +25,7 @@
 | 文档 | 路径 | 说明 |
 |------|------|------|
 | 命令集目录 | `evolcore/INDEX.md` | msg/group/agent/aid/storage/ctl/rpc/bench 全集索引 |
+| 联系人命令 | `evolcore/contact.md` | Contact Book 拉黑与托管会话权限边界 |
 
 ## 身份
 
@@ -46,7 +47,7 @@
 
 | 文档 | 路径 | 说明 |
 |------|------|------|
-| Trigger 命令手册 | `evolcore/trigger.md` | 创建、管理、运行定时与事件 trigger |
+| Trigger 命令手册 | `evolcore/trigger.md` | 使用 `create` 创建并管理、运行定时与事件 trigger；`set` 为兼容别名 |
 | EventBus 事件目录 | `evolcore/event.md` | event source 可监听事件、payload、filter 与循环防护规则 |
 
 ## ECK 模板

package/kits/docs/channels/aun.md

@@ -35,19 +35,10 @@ AUN 渠道是**隐式**的——它不写在 `channels[]` 数组里，而是从
 
 > `owners`/`admins` 用 **AID**，不是渠道原生 ID。
 
-### 进程级配置（`$EVOLCORE_HOME/config.json`）
+### AUN keystore seed
 
-E2EE 加密种子是**进程级**的，所有 agent 共享，不在 agent config 里：
-
-```json
-{
-  "aun": {
-    "encryptionSeed": "<seed>"
-  }
-}
-```
-
-留空时 SDK 依次回退 `AUN_ENCRYPTION_SEED` 环境变量 → 默认 `'evol'`。
+AUN keystore seed 由 EvolCore 使用固定应用值管理，不再提供配置项或环境变量入口。
+检测到历史自定义值时 daemon 会拒绝启动并提示联系管理人员，避免用错误值加载现有身份。
 
 > Gateway 不在配置里手填：连接时从 AID 自动发现（见下）。Keystore 默认落在 `$EVOLCORE_HOME`。
 
@@ -58,7 +49,7 @@ E2EE 加密种子是**进程级**的，所有 agent 共享，不在 agent config
 - **身份与信任**：每条入站消息携带发送者 AID，经四级 X.509 证书链（Root CA → Registry CA → Issuer CA → Agent）验签。
 - **agent.md 缓存**：对端名片 `https://<aid>/agent.md` 由 **AUN SDK 自动拉取并缓存**（`AgentMdManager`，带 ETag/TTL，默认 1 天内不重复探测）。缓存落在 **`$EVOLCORE_HOME/AIDs/<aid>/`**，每个 AID 两个文件：`agent.md`（带签名正文）+ `agentmd.json`（元数据：etag/last_modified/checked_at/verify_status）。本端与对端的 agent.md 都缓存于此。
   - 关系层另存一份**派生**的精简身份 `relations/<peerKey>/peer-identity.json`（type/isAgent/name），由 evolcore 从 agent.md 提取，不是 agent.md 本体。
-- **E2EE 加密**：可选端到端加密，回复默认跟随对端消息加密状态（密文回密文，明文回明文）；种子由进程级 `aun.encryptionSeed` 提供。
+- **E2EE 加密**：可选端到端加密，回复默认跟随对端消息加密状态（密文回密文，明文回明文）；keystore seed 由 EvolCore 固定管理。
 - **断线重连**：SDK 内置退避策略自动重连。实时连接状态用 `ec watch aid` 查看（`ec aid` 是身份/证书管理，不显示连接状态）。
 - **群 ID 格式**：当前协议规范使用 `g-{slug}.issuer-domain` canonical 形式，输入也可接受本域简写 `g-{slug}` 或兼容形式 `g-{slug}@issuer-domain`。历史会话里可能仍出现 `group.{issuer}/{group_no}` 一类旧格式，运行时需兼容读取。
 - **群分发模式**：`dispatch_mode=broadcast|mention` 是群级配置，只决定哪些群消息进入 Agent LLM 上下文，不影响 AUN 协议层投递；被过滤消息仍应本地存档。

package/kits/docs/evolcore/INDEX.md

@@ -4,8 +4,9 @@
 运行时 evolcore 会通过 `commands` fragment 按当前场景（有无 peer/group、对端角色）
 注入一张精简能力卡，指向本目录下对应文档；需要完整用法时 Read 对应文档。
 
-> 命令通用约定：以自己 AID 为发送者；必须走 CLI，不在会话里直接输出对外消息；
-> `--format json` 所有命令通用；`--app <name>` 指定应用 slot（独立消费通道）。
+> 对外通信命令以自己的 AID 为发送者；当前渠道是否需要 CLI 回复，以运行时注入的
+> `channel` 规则为准。参数不是全局通用的：`--format json` 仅用于对应帮助中明确支持的命令，
+> `--app <name>` 仅用于消息 pull/ack、消费类 RPC 和明确支持 app slot 的文件操作。
 
 ## 如何使用本索引
 
@@ -34,6 +35,7 @@
 | `ec fs` | AUN 文件系统统一入口 | 上传/下载/看文件/列目录/删文件/配额/群空间 | 任意有渠道场景 | `fs.md` |
 | `ec storage` | 文件存储底层调试入口 | storage 调试/旧命令/底层上传下载 | 任意有渠道场景 | `storage.md` |
 | `ec agent` | EvolAgent 生命周期 | 创建/启停/热重载/改配置 | 管理员（owner/admin） | `agent.md` |
+| `ec contact` | Contact Book 与访问控制 | 拉黑/解除拉黑/查拉黑 | 读 owner/admin；写仅 owner | `contact.md` |
 | `ec rpc` | 底层 AUN RPC（逃生通道） | 直接调协议方法 | 高级/兜底 | `rpc.md` |
 
 ## 会话自管理类（不连 AUN，操作当前会话）
@@ -50,7 +52,7 @@
 | `ec response` | 响应模式管理（按作用域持久化） | 切换响应模式/列响应模式/看当前模式/改响应配置 | `response.md` |
 | `ec config` | 配置体系底层入口（读写/快照/回滚） | 看配置/改配置/查字段/查schema/校验/快照/回滚/历史/启动记录 | `config.md` |
 | `ec stats` | Token 用量与费用统计 | 用量/费用/统计/预算/token/cost | `stats.md` |
-| `ec trigger` | 定时与事件触发器管理 | 触发器/定时任务/cron/提醒/定时检查/自动执行/巡检/禁用 trigger/删除 trigger | `trigger.md` |
+| `ec trigger` | 定时与事件触发器管理（创建用 `create`，`set` 为兼容别名） | 触发器/定时任务/cron/提醒/定时检查/自动执行/巡检/禁用 trigger/删除 trigger | `trigger.md` |
 | `ec trigger event` | EventBus 事件目录 | 事件触发/事件目录/EventBus/source.type=event/filter.match | `event.md` |
 
 ## 开发者工具（非 agent 会话能力）