evolcore 0.0.11 → 0.0.13

package/dist/utils/ecweb-supervisor.js

@@ -0,0 +1,332 @@
+import fs from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+import { resolvePaths } from '../paths.js';
+import { WEB_PACKAGE_NAME } from '../product.js';
+import { resolveGlobalPkg } from './npm-ops.js';
+import { ecwebVersionRequirementError, resolveEcwebLaunchCommand } from './ecweb-utils.js';
+import * as platform from './cross-platform.js';
+import { getProcessStartTime } from './process-introspect.js';
+const INSTANCE_FILE_RE = /^(?:ecweb|watch-web)-\d+\.json$/;
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function isAlive(record) {
+    if (!Number.isInteger(record.pid) || record.pid <= 0)
+        return false;
+    // ECWeb versions before the supervisor used a different Linux boot-time
+    // calculation, so their `startedAt` can be off by seconds or minutes even
+    // while the PID and HTTP listener are healthy.  The instance file is already
+    // scoped to this EVOLCORE_HOME; use liveness here and let the HTTP probe be
+    // the ownership/health check.  PID/start-time validation remains in the
+    // explicit kill path below.
+    return platform.isProcessRunning(record.pid);
+}
+function readEntries() {
+    const dir = resolvePaths().instanceDir;
+    let files;
+    try {
+        files = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const entries = [];
+    for (const file of files) {
+        if (!INSTANCE_FILE_RE.test(file))
+            continue;
+        const filePath = path.join(dir, file);
+        try {
+            const value = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+            if (Number.isInteger(value.pid) && value.pid > 0) {
+                entries.push({
+                    filePath,
+                    record: {
+                        pid: value.pid,
+                        port: Number.isInteger(value.port) ? value.port : 42705,
+                        ...(typeof value.startedAt === 'number' ? { startedAt: value.startedAt } : {}),
+                    },
+                });
+            }
+        }
+        catch {
+            // A partially-written instance file is ignored until the next check.
+        }
+    }
+    return entries;
+}
+function removeEntry(entry) {
+    try {
+        fs.unlinkSync(entry.filePath);
+    }
+    catch { }
+}
+function removeEntriesForPid(pid) {
+    for (const entry of readEntries()) {
+        if (entry.record.pid === pid)
+            removeEntry(entry);
+    }
+}
+async function probe(port) {
+    try {
+        const response = await fetch(`http://127.0.0.1:${port}/`, {
+            signal: AbortSignal.timeout(1500),
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Owns the ECWeb process for the lifetime of the daemon.
+ *
+ * The CLI may have started ECWeb moments earlier (ec start/restart/watch web).
+ * We first adopt a healthy registered instance and only spawn after a few
+ * seconds of failed discovery. This closes the race between the CLI launcher,
+ * ECWeb's own stale-instance cleanup, and daemon startup.
+ */
+export function createEcwebSupervisor(options) {
+    const failureThreshold = Math.max(1, options.failureThreshold ?? 3);
+    const checkIntervalMs = Math.max(1000, options.checkIntervalMs ?? 5000);
+    let active = null;
+    let child = null;
+    let logFd = null;
+    let timer = null;
+    let failureCount = 0;
+    let startInFlight = null;
+    let stopping = false;
+    const logFile = path.join(resolvePaths().logs, 'ecweb-daemon.log');
+    const setActiveFromEntry = (entry, owned) => {
+        active = {
+            pid: entry.record.pid,
+            port: entry.record.port,
+            // Capture the current PID start time rather than trusting the record.
+            // Older ECWeb builds could write a clock-skewed `startedAt` value.
+            startedAt: getProcessStartTime(entry.record.pid)
+                ?? (typeof entry.record.startedAt === 'number' ? entry.record.startedAt : null),
+            owned,
+        };
+    };
+    const findHealthyInstance = async () => {
+        for (const entry of readEntries()) {
+            if (!isAlive(entry.record)) {
+                removeEntry(entry);
+                continue;
+            }
+            if (await probe(entry.record.port))
+                return entry;
+        }
+        return null;
+    };
+    const waitForHealthyInstance = async (timeoutMs) => {
+        const deadline = Date.now() + timeoutMs;
+        do {
+            const found = await findHealthyInstance();
+            if (found)
+                return found;
+            if (Date.now() >= deadline)
+                break;
+            await sleep(250);
+        } while (!stopping);
+        return null;
+    };
+    const closeLogStream = () => {
+        if (logFd === null)
+            return;
+        try {
+            fs.closeSync(logFd);
+        }
+        catch { }
+        logFd = null;
+    };
+    const killActive = async () => {
+        const current = active;
+        if (!current) {
+            // During the short window between spawn() and ECWeb writing its
+            // instance record there is no `active` entry yet, but the daemon still
+            // owns the child and must not leave it behind on shutdown.
+            const pendingPid = child?.pid;
+            if (pendingPid && platform.isProcessRunning(pendingPid)) {
+                try {
+                    platform.killProcess(pendingPid, true);
+                }
+                catch { }
+                await platform.waitForProcessExit(pendingPid, 5000);
+            }
+            return;
+        }
+        const actual = getProcessStartTime(current.pid);
+        // Never kill a reused PID.  `startedAt` was captured from the live process
+        // when it was adopted/spawned, so this remains safe even for legacy records
+        // whose on-disk timestamp used a different clock.
+        const sameProcess = current.startedAt !== null && actual !== null
+            ? current.startedAt === actual
+            : false;
+        if (sameProcess && platform.isProcessRunning(current.pid)) {
+            try {
+                platform.killProcess(current.pid, true);
+            }
+            catch { }
+            await platform.waitForProcessExit(current.pid, 5000);
+        }
+        removeEntriesForPid(current.pid);
+        active = null;
+    };
+    const spawnEcweb = async () => {
+        const root = resolvePaths().root;
+        const localEntry = path.join(root, 'ecweb', 'dist', 'index.js');
+        const globalPkg = resolveGlobalPkg(WEB_PACKAGE_NAME);
+        let launch = resolveEcwebLaunchCommand(['--home', root, '--port', String(options.port)], {
+            installedPkg: globalPkg,
+        });
+        let cwd = root;
+        let version = globalPkg?.version;
+        if (!launch && fs.existsSync(localEntry)) {
+            launch = {
+                command: process.execPath,
+                args: [localEntry, '--home', root, '--port', String(options.port)],
+                entry: localEntry,
+                source: 'package-bin',
+            };
+            cwd = path.dirname(path.dirname(localEntry));
+            try {
+                version = JSON.parse(fs.readFileSync(path.join(root, 'ecweb', 'package.json'), 'utf8')).version;
+            }
+            catch { }
+        }
+        if (!launch) {
+            options.logger.warn(`ECWeb 启动入口不存在，请安装 ${WEB_PACKAGE_NAME}@latest`);
+            return;
+        }
+        const versionError = ecwebVersionRequirementError(version);
+        if (versionError) {
+            options.logger.error(`ECWeb 未启动: ${versionError}`);
+            return;
+        }
+        fs.mkdirSync(resolvePaths().logs, { recursive: true });
+        fs.appendFileSync(logFile, `\n# daemon supervisor start ${new Date().toISOString()}\n`);
+        // `spawn()` accepts inherited file descriptors, but not a WriteStream
+        // whose fd has not been opened yet. Open once and pass the numeric fd to
+        // both stdout and stderr; the parent closes its copy after spawning.
+        logFd = fs.openSync(logFile, 'a');
+        const childLogFd = logFd;
+        let spawned;
+        try {
+            spawned = spawn(launch.command, launch.args, {
+                cwd,
+                detached: true,
+                stdio: ['ignore', childLogFd, childLogFd],
+                windowsHide: platform.isWindows,
+                env: { ...process.env, EVOLCORE_HOME: root },
+            });
+        }
+        catch (error) {
+            closeLogStream();
+            options.logger.error(`ECWeb 子进程创建失败: ${error?.message || error}`);
+            return;
+        }
+        closeLogStream();
+        child = spawned;
+        spawned.once('error', (error) => {
+            options.logger.error(`ECWeb 子进程创建失败: ${error.message}`);
+        });
+        spawned.once('exit', (code, signal) => {
+            options.logger.warn(`ECWeb 进程退出 (PID: ${spawned.pid ?? 'unknown'}, code=${code ?? 'null'}, signal=${signal ?? 'null'})`);
+            if (child === spawned)
+                child = null;
+            if (!stopping) {
+                active = null;
+                failureCount = failureThreshold;
+            }
+            closeLogStream();
+        });
+        spawned.unref();
+        if (!spawned.pid) {
+            closeLogStream();
+            options.logger.warn('ECWeb 启动失败：未取得子进程 PID');
+            return;
+        }
+        options.logger.info(`✓ ECWeb supervisor 已启动 (PID: ${spawned.pid})，日志: ${logFile}`);
+        // ECWeb writes its own instance record after binding. Do not fabricate a
+        // record here; the watchdog will adopt the real record on its next tick.
+        // Returning immediately keeps daemon startup independent of HTTP bind
+        // latency while ServiceProxy continues to wait for the instance file.
+    };
+    const ensureRunning = async () => {
+        if (stopping || startInFlight)
+            return;
+        const healthy = await findHealthyInstance();
+        if (healthy) {
+            const changed = !active || active.pid !== healthy.record.pid || active.port !== healthy.record.port;
+            setActiveFromEntry(healthy, active?.pid === healthy.record.pid ? active.owned : false);
+            failureCount = 0;
+            if (changed)
+                options.logger.info(`✓ ECWeb supervisor 接管现有实例 (PID: ${healthy.record.pid}, 端口: ${healthy.record.port})`);
+            return;
+        }
+        failureCount += 1;
+        if (failureCount < failureThreshold)
+            return;
+        // A manual `ec watch web` may be between killing the old process and
+        // registering the replacement. Re-scan immediately before spawning.
+        const replacement = await waitForHealthyInstance(1500);
+        if (replacement) {
+            setActiveFromEntry(replacement, false);
+            failureCount = 0;
+            return;
+        }
+        startInFlight = (async () => {
+            await killActive();
+            await spawnEcweb();
+            failureCount = 0;
+        })().finally(() => { startInFlight = null; });
+        await startInFlight;
+    };
+    return {
+        async start() {
+            if (stopping)
+                return;
+            // CLI/restart-monitor writes the instance record before the daemon is
+            // ready. Give that process enough time to bind before launching another.
+            const existing = await waitForHealthyInstance(1_500);
+            if (existing) {
+                setActiveFromEntry(existing, false);
+                options.logger.info(`✓ ECWeb supervisor 接管现有实例 (PID: ${existing.record.pid}, 端口: ${existing.record.port})`);
+            }
+            else {
+                failureCount = failureThreshold;
+                await ensureRunning();
+            }
+            timer = setInterval(() => {
+                void ensureRunning().catch((error) => {
+                    options.logger.error(`ECWeb watchdog 检查失败: ${error?.message || error}`);
+                });
+            }, checkIntervalMs);
+            timer.unref?.();
+        },
+        async stop() {
+            if (stopping)
+                return;
+            stopping = true;
+            if (timer)
+                clearInterval(timer);
+            timer = null;
+            if (startInFlight) {
+                try {
+                    await startInFlight;
+                }
+                catch { }
+            }
+            await killActive();
+            if (child) {
+                try {
+                    child.removeAllListeners();
+                }
+                catch { }
+                child = null;
+            }
+            closeLogStream();
+        },
+    };
+}

package/dist/utils/error-utils.js

@@ -2,6 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import { getPackageRoot, resolvePaths } from '../paths.js';
 import { logger } from './logger.js';
+import { isSandboxInitializationFailure } from '../core/permission/sandbox-runtime.js';
 export var ErrorType;
 (function (ErrorType) {
     ErrorType["SDK_TIMEOUT"] = "sdk_timeout";
@@ -11,6 +12,7 @@ export var ErrorType;
     ErrorType["STREAM_ERROR"] = "stream_error";
     ErrorType["CONTEXT_TOO_LONG"] = "context_too_long";
     ErrorType["MODEL_UNAVAILABLE"] = "model_unavailable";
+    ErrorType["SANDBOX_INITIALIZATION_FAILED"] = "sandbox_initialization_failed";
     ErrorType["UNKNOWN"] = "unknown";
 })(ErrorType || (ErrorType = {}));
 /**
@@ -269,6 +271,9 @@ export function classifyError(error) {
         || /api error: 404\b/.test(msg)) {
         return ErrorType.MODEL_UNAVAILABLE;
     }
+    if (isSandboxInitializationFailure(error)) {
+        return ErrorType.SANDBOX_INITIALIZATION_FAILED;
+    }
     if (msg.includes('401') || msg.includes('authentication_error') || msg.includes('unauthorized')) {
         return ErrorType.AUTH_ERROR;
     }
@@ -328,6 +333,8 @@ export function getErrorMessage(error, terminalReason, includeEmoji = true) {
                 return `${prefix}工具执行失败，请检查操作或重试`;
             case 'permission_denied':
                 return `${prefix}权限被拒绝，操作已取消`;
+            case 'sandbox_initialization_failed':
+                return `${warnPrefix}只读执行沙箱启动失败（sandbox_initialization_failed），当前任务未执行；请检查 user namespace/seccomp 配置后重试`;
             case 'aborted_streaming':
             case 'aborted_tools':
                 return `${prefix}任务已中断`;
@@ -345,6 +352,9 @@ export function getErrorMessage(error, terminalReason, includeEmoji = true) {
     if (msg.includes('CONTEXT_COMPACT_FAILED') || isContextTooLongText(msg)) {
         return `${warnPrefix}上下文过长，自动压缩失败，请手动输入 /compact 重试`;
     }
+    if (isSandboxInitializationFailure(error)) {
+        return `${warnPrefix}只读执行沙箱启动失败（sandbox_initialization_failed），当前任务未执行；请检查 user namespace/seccomp 配置后重试`;
+    }
     if (msg.includes('401') || msg.includes('authentication_error') || msg.toLowerCase().includes('unauthorized')) {
         return `${errPrefix}API Key 无效，请检查密钥配置。使用 /status 查看当前配置`;
     }

package/dist/utils/npm-ops.js

@@ -20,7 +20,7 @@ export async function npmInstallGlobal(pkg) {
     // Windows: run via cmd /c to avoid shell:true deprecation warning on Node 22.
     // Unix: npm directly, no shell needed.
     if (isWindows) {
-        cmd = 'cmd';
+        cmd = process.env.ComSpec || path.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'cmd.exe');
         args = ['/c', 'npm', 'install', '-g', pkg];
     }
     else {
@@ -28,14 +28,14 @@ export async function npmInstallGlobal(pkg) {
         args = ['install', '-g', pkg];
     }
     try {
-        await execFileAsync(cmd, args, { timeout: 180000 });
+        await execFileAsync(cmd, args, { timeout: 180000, windowsHide: isWindows });
     }
     catch (e) {
         if (e.stderr?.includes('EACCES') || e.message?.includes('EACCES')) {
             if (isWindows) {
                 throw new Error('权限不足。请以管理员身份运行 PowerShell 或 CMD，然后重试');
             }
-            await execFileAsync('sudo', ['npm', 'install', '-g', pkg], { timeout: 180000 });
+            await execFileAsync('sudo', ['npm', 'install', '-g', pkg], { timeout: 180000, windowsHide: false });
         }
         else {
             throw e;
@@ -103,7 +103,7 @@ export function resolveGlobalPkg(pkgName) {
         // 避免 "args 数组 + shell:true" 组合触发 Node DeprecationWarning，且无注入风险。
         const npmCmd = isWindows ? 'npm.cmd' : 'npm';
         const globalRoot = execSync(`${npmCmd} root -g`, {
-            encoding: 'utf-8', timeout: 10000,
+            encoding: 'utf-8', timeout: 10000, windowsHide: true,
         }).trim();
         const pkgPath = path.join(globalRoot, ...pkgName.split('/'), 'package.json');
         if (fs.existsSync(pkgPath)) {
@@ -171,7 +171,7 @@ export async function tryUpgrade() {
 /**
  * 通用全局包升级流程：检查 → 比较 → 安装（失败重试一次）。
  * 仅在包已安装时检查升级，未安装则跳过（resolveFn 返回 null）。
- * fastaun / EC Web 等独立全局包共用此逻辑。
+ * 用于 EC Web 等真正独立于 EvolCore 的全局包。
  */
 export async function tryUpgradeGlobalPkg(resolveInstalled, pkgName) {
     if (isLinkedInstall()) {
@@ -201,10 +201,3 @@ export async function tryUpgradeGlobalPkg(resolveInstalled, pkgName) {
     }
     return { status: 'failed', from: localVer, to: remoteVer, error: lastError };
 }
-/**
- * AUN SDK 升级流程：检查 → 比较 → 安装
- * 仅在 SDK 已安装时检查升级，未安装则跳过。
- */
-export async function tryUpgradeAunSdk(resolveAunCoreSdkPkg, AUN_CORE_SDK_PKG) {
-    return tryUpgradeGlobalPkg(resolveAunCoreSdkPkg, AUN_CORE_SDK_PKG);
-}

package/dist/utils/tool-summary.js

@@ -63,6 +63,17 @@ export function summarizeToolInput(toolName, input) {
         || input.url
         || '';
 }
+/**
+ * Audit-safe tool summary. Keep the useful operation shape while masking
+ * credentials commonly embedded in shell commands or tool arguments.
+ */
+export function summarizeToolInputForAudit(toolName, input) {
+    return summarizeToolInput(toolName, input)
+        .replace(/\b([A-Z0-9_]*(?:TOKEN|KEY|SECRET|PASSWORD|CREDENTIAL)[A-Z0-9_]*)\s*=\s*(?:"[^"]*"|'[^']*'|\S+)/gi, '$1=[REDACTED]')
+        .replace(/\b(authorization\s*:\s*Bearer\s+)[^\s"',;]+/gi, '$1[REDACTED]')
+        .replace(/\b(api[_-]?key|access[_-]?token|refresh[_-]?token|password|secret|authorization|cookie)\s*([=:])\s*(?:"[^"]*"|'[^']*'|\S+)/gi, '$1$2[REDACTED]')
+        .replace(/\bBearer\s+[^\s,;]+/gi, 'Bearer [REDACTED]');
+}
 const EDIT_PREVIEW_MAX_LINES = 14;
 const EDIT_PREVIEW_CONTEXT_LINES = 2;
 const EDIT_PREVIEW_INLINE_GAP_LINES = 4;

package/kits/docs/channels/aun.md

@@ -52,5 +52,5 @@ AUN keystore seed 由 EvolCore 使用固定应用值管理，不再提供配置
 - **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 协议层投递；被过滤消息仍应本地存档。
+- **群 @ 处理策略**：`mention_mode=disabled|mention-only` 是群级配置，只决定哪些群消息进入 Agent LLM 上下文，不影响 AUN 协议层投递；被过滤消息仍应本地存档。
 - **身份体系**：对端以 AID 标识，关系层 peerKey 形如 `aun#alice.aid.pub`。

package/kits/docs/context-assembly.md

@@ -163,6 +163,7 @@ manifest 是 `{ "$schema_version": 1, "sections": [...] }`。每个 section：
 
 - 覆盖文件含 `"mode": "replace"` → **完全替换**，只用覆盖文件的 sections。
 - 否则 **patch 合并**：以 `id` 为键，覆盖文件里同 id 的字段浅合并进基础 section（`{...base, ...override}`），新 id 追加。
+- 旧 patch 中的 `relation-group-profile` 已废弃并会被忽略；群与私聊 profile 统一通过 `peer-profile` 配置，避免同一文件重复加载。`mode: "replace"` 不做此兼容处理。
 
 合并后统一按 `order` 升序排序。改某段行为（如关掉某层、调顺序、换条件）优先用覆盖文件，不动基础 manifest。
 
@@ -295,7 +296,6 @@ coding 场景（无 channel/无身份）下，`chatType`、`channel`、`selfAid`
 | 40 | venue-fragment | fragment | chatType≠null | ✓ |
 | 41 | venue-chattype | `$KITS_DOCS/venues/{{chatType}}.md` | chatType≠null | ✗ |
 | 42 | venue-channel-chattype | `$KITS_DOCS/venues/{{channel}}-{{chatType}}.md` | chatType≠null | ✗ |
-| 43 | relation-group-profile | `$RELATIONS_DIR/{{peerKey}}/profile.md` | groupId≠null | ✗ |
 | 44 | venue-client | `$KITS_DOCS/venues/client-{{clientType}}.md` | clientType≠null | ✗ |
 | 50 | channel-layer | fragment | channel≠null | ✓ |
 | 55 | commands | fragment | channel≠null | ✓ |
@@ -322,7 +322,7 @@ $KITS_DOCS/venues/                  通用环境文档（随包发布，只读
 ```
 
 > **注意**：具体群/私聊实例的 profile 数据落**关系层** `$RELATIONS_DIR/<peerKey>/profile.md`，
-> 由 `relation-group-profile` 段注入，不在 venues 目录。
+> 统一由 `peer-profile` 段注入，不在 venues 目录；群不会再通过另一个 section 重复加载。
 
 ## 输出结构
 

package/kits/docs/evolcore/agent.md

@@ -17,9 +17,10 @@ ec agent <aid>
 ec agent new [aid]
 
 # 创建 agent（非交互式，自动化场景）
-ec agent new <aid> --non-interactive --project <绝对路径> \
-  [--baseagent claude|codex|gemini] [--owner <aid>] \
-  [--name "<显示名>"] [--description "<text>"] [--force]
+ec agent new <aid> --non-interactive \
+  [--project <路径>] [--baseagent claude|codex|gemini|ecagent] \
+  [--owner <aid>] [--name "<显示名>"] [--description "<text>"] \
+  [--dry-run] [--force]
 
 # 启用 / 停用
 ec agent enable <aid>
@@ -44,9 +45,13 @@ ec agent delete <aid> [--purge]
 
 ## 非交互创建必填项
 
-`ec agent new <aid> --non-interactive` 时：
-- 必填：`--project <absolute path>`
-- 可选：`--baseagent`（默认 PATH 中第一个可用项）、`--owner`、`--name`、`--description`、`--force`（覆盖已有 config.json）
+`ec agent new <aid> --non-interactive` 时，只有 `<aid>` 必填：
+- `--project` 缺省为当前目录，并自动转为绝对路径。
+- `--baseagent` 优先使用 `agents/defaults.json`，否则检测本机可用基座。
+- `--owner` 缺省使用 `daemon.json` 的第一个 owner；未配置时省略。
+- `--name` / `--description` 缺省读取当前项目 `package.json`，再回退到目录名 / 空描述。
+- `--dry-run` 只输出最终创建计划，不注册 AID、不写配置、不上传 `agent.md`。
+- `--force` 覆盖已有 `config.json`；AID 密钥保留。
 
 ## 头像更新
 

package/kits/docs/evolcore/aid.md

@@ -2,6 +2,20 @@
 
 管理本地 AID 身份（证书、私钥、agent.md 名片），以及远程探测对端 AID。触发词：身份/证书/名片/探测对端/创建身份。
 
+## 运行边界
+
+本页列出独立终端中 `ec aid` 的完整 CLI 能力。在 EvolCore 托管 Agent 会话中，为防止会话枚举、创建、删除或切换身份，只允许当前 self AID 上的以下精确命令：
+
+```bash
+ec aid show <当前 self AID> [--format json]
+ec aid lookup <当前 self AID> [--format json]
+ec aid agentmd get <当前 self AID> [--format json]
+# 仅 request / bypass
+ec aid agentmd put <当前 self AID> [--format json]
+```
+
+仅允许不带选项的基本形式，或在末尾附加一组完整的 `--format json`；不能使用 `--aun-path`、未知选项、管道、重定向或其他 AID。`show`、`lookup` 和 `agentmd get` 是 self-scoped 查询，可在所有 `permissionMode` 执行；`agentmd put` 会发布远端名片，属于写操作，仅允许 `request`、`bypass`，`readonly`、`auto` 和未知模式均拒绝。该身份范围边界早于模式审批，`bypass` 也不能跨越当前 self AID。`show` 会对自身身份做本地签名/验签自检，但不输出私钥；`lookup` 只探测已知的自身 AID；`get` 不改变身份或远端数据，但会下载并验签自身公开名片，同时刷新本地 AID 缓存。`list`、其他 AID 的 `show/lookup/agentmd get/put` 以及 `new/delete` 均拒绝。独立终端不受此托管会话限制。
+
 ## 子命令
 
 ```bash

package/kits/docs/evolcore/trigger.md

@@ -132,11 +132,24 @@ Trigger V3 第二阶段使用 `execution.type` 区分执行位置：
 ```bash
 --target-channel <channelKey>
 --target-channel-id <channelId>
+--target-chat-type <private|group>
 --target-session main
 --target-session thread --target-thread-id <threadId>
 ```
 
-AUN 渠道由 agent AID 隐式创建，不需要写入 agent 配置的 `channels[]`。CLI 和 Trigger V3.1 definition 均可将 `aun` 用作 `channelKey` 简写；保存前会按 `agentAid` 展开为 `aun#<agentAid>#main`。其他渠道仍需指定完整的实例 channel key。
+AUN 渠道由 agent AID 隐式创建，不需要写入 agent 配置的 `channels[]`。CLI 和 Trigger V3.1 definition 均可将 `aun` 用作 `channelKey` 简写；保存前会按 `agentAid` 展开为 `aun#<agentAid>#main`。AUN 目标必须明确设置 `chatType`；`channelId` 在私聊时是对端 ID，在群聊时就是群 ID，不再额外保存 `groupId`。读取缺少 `chatType` 的旧 AUN Trigger definition 时，迁移逻辑会仅在该次迁移中按 `private` 补齐并回写；新建和编辑仍要求显式指定。其他渠道仍需指定完整的实例 channel key。
+
+```json
+{
+  "strategy": "target",
+  "target": {
+    "channelKey": "aun",
+    "channelId": "peer.agentid.pub",
+    "chatType": "private",
+    "session": "main"
+  }
+}
+```
 
 Trigger V3.1 feedback 是单策略：
 
@@ -307,6 +320,7 @@ ec trigger create --exec script --file ./trigger-dir --enable
     "target": {
       "channelKey": "<channelKey>",
       "channelId": "<channelId>",
+      "chatType": "private",
       "session": "main"
     }
   },
@@ -388,6 +402,7 @@ ec trigger create --exec script --file ./trigger-dir --enable
     "target": {
       "channelKey": "<channelKey>",
       "channelId": "<channelId>",
+      "chatType": "private",
       "session": "main"
     },
     "onReply": {
@@ -466,6 +481,7 @@ flag 模式不能配置过滤条件。需要根据事件 payload 过滤时，写
     "target": {
       "channelKey": "<channelKey>",
       "channelId": "<channelId>",
+      "chatType": "private",
       "session": "main"
     }
   },

package/kits/docs/prompt-loading-architecture.md

@@ -69,7 +69,7 @@
 | **vars 粒度** | 会话级（一次构造，整批复用） | item 级（每条叠加 peerName/now/images） |
 | **模板空行** | 删除（stripBlankLines=true，紧凑） | 保留（stripBlankLines=false，消息多段） |
 | **content 注入** | N/A | 哨兵末步字面量注入（防二次解析） |
-| **缓存** | per-sessionId（跨消息复用文件内容） | per-renderMessageBody 调用（局部） |
+| **缓存** | 随包 `kits/` 文件跨 session 缓存到 reload；personal/relations 等运行时文件按 mtime 刷新 | 随包模板缓存到 reload，消息数据不缓存 |
 | **debug 输出** | `eck-debug/context-*.md` `fragments-*.md` `manifest-*.md` `vars-*.json` | `eck-debug/msg-render-*.md` |
 
 ---
@@ -109,7 +109,6 @@
 | 40 | venue-fragment | chatType≠null | ✓ | 环境层 fragment |
 | 41 | venue-chattype | chatType≠null | ✗ | `venues/{{chatType}}.md` |
 | 42 | venue-channel-chattype | chatType≠null | ✗ | `venues/{{channel}}-{{chatType}}.md` |
-| 43 | venue-group-profile | groupId≠null | ✗ | 群 venue profile.md |
 | 44 | venue-client | clientType≠null | ✗ | `venues/client-{{clientType}}.md` |
 | 50 | channel-layer | channel≠null | ✓ | 渠道层 fragment |
 | 55 | commands | channel≠null | ✓ | 命令集能力卡 |

package/kits/docs/venues/group.md

@@ -5,7 +5,7 @@
 ## 行为准则
 - `mentionMode: mention-only` — 仅响应明确 @ 自己的消息
 - `mentionMode: disabled` — 所有消息可见，自主判断是否参与。这不是叫你每条都回，而是你可以像真人一样：感兴趣的接话，不感兴趣的就跳过。回得短一点、快一点，让对话流动起来，不要一个人长篇大论堵住别人的空间
-- 查看 venue 档案（venue-group-profile）了解本群文化与策略
+- 查看关系档案（peer-profile）了解本群文化与策略
 - 如果上下文中出现“群规则”，它来自当前群资源空间的本地同步缓存；群规则优先于通用群聊指引
 - 群发言会被多人看到，谨言慎行
 - 具体渠道（AUN/飞书/微信等）的群聊特有指引见对应渠道文档

package/kits/eck_manifest.json

@@ -127,18 +127,6 @@
       ] },
       "description": "渠道+场景文档（如 feishu-group）"
     },
-    {
-      "id": "relation-group-profile",
-      "type": "file",
-      "file": "$RELATIONS_DIR/{{peerKey}}/profile.md",
-      "order": 43,
-      "needsInjection": false,
-      "when": { "and": [
-        { "var": "groupId", "neq": null },
-        { "var": "lifecycle", "neq": "bootstrapping" }
-      ] },
-      "description": "具体群关系文档"
-    },
     {
       "id": "relation-group-rules",
       "type": "file",

package/kits/migrations/migrate-contact-book-v2.mjs

@@ -49,8 +49,7 @@ function isExplicitGroupId(value) {
   return (id.startsWith('group.') && id.includes('/'))
     || /^\d+\.[a-z0-9.-]+$/i.test(id)
     || /^grp_[a-z0-9_-]+$/i.test(id)
-    || /^g-[a-z0-9_-]+(?:[.@][a-z0-9.-]+)?$/i.test(id)
-    || /(?:^|\.)groupid\.pub$/i.test(id);
+    || /^g-[a-z0-9_-]+(?:[.@][a-z0-9.-]+)?$/i.test(id);
 }
 
 function readJson(file) {

package/kits/rules/04-relation.md

@@ -39,7 +39,7 @@ relations/
 
 | 条目 | 真实状态 |
 |------|----------|
-| `<peerKey>/profile.md` | manifest 声明了加载槽（`peer-profile`、`relation-group-profile`，缺失即跳过），但**没有任何代码写它**，磁盘上零文件。你可以手写一份，它会被加载 |
+| `<peerKey>/profile.md` | manifest 通过统一的 `peer-profile` 槽加载（缺失即跳过），群聊和私聊不再重复声明；目前**没有任何代码写它**，可以手写一份供上下文加载 |
 | `_index/name_<name>.json` 名字反查索引 | 目录会被创建，但**无任何读写代码**，磁盘上全是空目录。"已知 name 反查 peerKey" 这条路走不通 |
 | `<peerKey>/history.jsonl` | 关系层无此实现（同名文件都属于 handoff / trigger / CC 自己的历史） |
 | `_trash/` | 只创建目录，没有 merge/split 重定向逻辑 |