evolcore 0.0.4 → 0.0.5

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 本文件记录 EvolCore 的重要变更。EvolClaw 版本线的历史记录已归档至
 [`docs/_archive/CHANGELOG-evolclaw.md`](docs/_archive/CHANGELOG-evolclaw.md)。
 
+## 0.0.5 (2026-07-31)
+
+### 消息准入
+
+- 群聊准入统一为开放、联系人、Owner 三种行为，移除额外的渠道白名单配置。
+- 访问策略的修改权限收归 Agent Owner。
+- 完善联系人准入、拉黑与 Owner 权限边界的判定。
+- Connect 群组入口展示实时群组数量。
+
+### 运行可靠性
+
+- 修复旧版本遗留的 AUN 会话目录身份恢复：可唯一判定身份时安全迁移，无法判定时保持原样并告警。
+- 修正 Linux 容器内进程启动时间与运行时长的计算偏差。
+
+### 初始化体验
+
+- 优化初始化向导的目录输入，支持家目录简写、错误重试与显式跳过。
+- 未完成初始化时自动运行向导，完成后继续启动服务。
+- 未配置 self-agent 时按实际可用入口给出创建提示。
+
 ## 0.0.4 (2026-07-30)
 
 ### 联系人身份与消息准入
@@ -13,9 +33,8 @@
 - 新增联系人请求服务，申请与状态流转改为原子操作，避免并发请求产生不一致。
 - 限制单实例和进程级待绑定请求数量，并限制无效绑定码的连续尝试次数。
 - 拒绝对不存在的联系人执行身份绑定和状态变更。
-- 群聊准入按 `access.policyMode` 分级：`open` 全面开放，`contacts` 下 AUN 群聊默认开放、
-  非 AUN 群聊仍需命中 `allowedGroupChannels`，`owners-only` 一律拒绝。缺少 `access` 配置的
-  既有 Agent 走 `open` 兼容视图，升级后群聊不会因白名单为空被拒。
+- 群聊准入按 `access.policyMode` 分级：`open` 对所有已配置渠道开放，`contacts` 将 Agent 已加入并接收到的
+  群聊视为授权，`owners` 仅 Owner 消息开放。
 
 ### 菜单与授权
 

package/dist/cli/daemon-commands.js

@@ -29,6 +29,22 @@ import { AGENT_DELEGATION_TOKEN_ENV } from '../core/auth/agent-delegation.js';
 import { WEB_CLI_BIN, WEB_PACKAGE_LATEST, WEB_PACKAGE_NAME } from '../product.js';
 import { rotateStdoutLog } from '../utils/log-writer.js';
 const execFileAsync = promisify(execFile);
+function printNoSelfAgentHints(options) {
+    const { daemonConfig, ecwebStarted, skipped } = options;
+    console.log('\nℹ 未配置任何 self-agent，Control Plane 已启动。');
+    console.log('  命令行：ec agent new <aid>.agentid.pub');
+    if (daemonConfig.aid && (daemonConfig.owners?.length ?? 0) > 0) {
+        console.log('  Evol App：可通过进程级菜单创建 agent');
+    }
+    if (ecwebStarted) {
+        console.log('  ECWeb：可通过控制台创建 agent');
+    }
+    if (skipped.length > 0) {
+        console.log('跳过的目录:');
+        for (const skippedAgent of skipped)
+            console.log(`  - ${skippedAgent.dirName}: ${skippedAgent.reason}`);
+    }
+}
 async function probeDaemon(socketPath, timeoutMs = 1000) {
     const response = await ipcQuery(socketPath, { type: 'ping' }, timeoutMs);
     if (response?.pong !== true || !Number.isInteger(response.pid) || response.pid <= 0)
@@ -196,8 +212,16 @@ export async function cmdStart(opts = {}) {
         }
         else {
             console.log('⚡ 未检测到初始化配置，自动启动初始化向导...\n');
-            await cmdInit();
-            return;
+            // cmdStart 直接调用 cmdInit，不会经过 CLI 的 `init` 分发分支；
+            // 这里需显式抑制 AUN SDK 的常规 keystore 日志。
+            const { suppressSdkLogs } = await import('../aun/aid/index.js');
+            suppressSdkLogs();
+            await cmdInit({ invokedByStart: true });
+            if (!loadDefaults()) {
+                console.log('⚠ 初始化未完成，未启动 EvolCore。');
+                return;
+            }
+            console.log('\n初始化完成，开始启动 EvolCore ....');
         }
     }
     // 控制 AID 门禁：缺 aid 且交互式 → 只补全控制 AID + owners（不重走 baseagent 向导）。
@@ -236,19 +260,12 @@ export async function cmdStart(opts = {}) {
     }
     // 检查至少有一个 self-agent
     const { agents, skipped } = loadAllAgents();
+    const isControlAidBootstrap = opts.bindBootstrap && !!daemonCfgStart.aid;
+    const shouldPrintNoSelfAgentHints = agents.length === 0 && !isControlAidBootstrap;
     if (agents.length === 0) {
-        if (opts.bindBootstrap && daemonCfgStart.aid) {
+        if (isControlAidBootstrap) {
             console.log('ℹ 未配置任何 self-agent，绑定 bootstrap 将仅启动控制 AID');
         }
-        else {
-            console.log('ℹ 未配置任何 self-agent，将仅启动 Control Plane。');
-            console.log('  可通过控制 AID 远程创建 agent，或稍后运行 ec agent new <aid>.agentid.pub');
-            if (skipped.length > 0) {
-                console.log(`跳过的目录:`);
-                for (const s of skipped)
-                    console.log(`  - ${s.dirName}: ${s.reason}`);
-            }
-        }
     }
     // 检查 instance 目录中的进程状态
     const status = scanInstances();
@@ -323,10 +340,22 @@ export async function cmdStart(opts = {}) {
             console.log(`  Logs: ${p.logs}/`);
             console.log(`⏱ ready in ${((Date.now() - cmdStartedAt) / 1000).toFixed(1)}s`);
             if (!ecwebStartedBeforeDaemon) {
-                startEcwebIfEnabled(p).catch((err) => {
+                startEcwebIfEnabled(p)
+                    .then((ecwebStarted) => {
+                    if (shouldPrintNoSelfAgentHints) {
+                        printNoSelfAgentHints({ daemonConfig: loadDaemonConfig(), ecwebStarted, skipped });
+                    }
+                })
+                    .catch((err) => {
                     console.error(`⚠ ECWeb 启动检查失败: ${err instanceof Error ? err.message : String(err)}`);
+                    if (shouldPrintNoSelfAgentHints) {
+                        printNoSelfAgentHints({ daemonConfig: loadDaemonConfig(), ecwebStarted: false, skipped });
+                    }
                 });
             }
+            else if (shouldPrintNoSelfAgentHints) {
+                printNoSelfAgentHints({ daemonConfig: loadDaemonConfig(), ecwebStarted: true, skipped });
+            }
         }, 500);
         let forwardingShutdown = false;
         const forwardSignal = (signal) => {
@@ -426,8 +455,10 @@ export async function cmdStart(opts = {}) {
             }
             console.log(`⏱ done in ${((Date.now() - cmdStartedAt) / 1000).toFixed(1)}s`);
             // ECWeb 自动后台启动
-            if (!ecwebStartedBeforeDaemon)
-                await startEcwebIfEnabled(p);
+            const ecwebStarted = ecwebStartedBeforeDaemon || await startEcwebIfEnabled(p);
+            if (shouldPrintNoSelfAgentHints) {
+                printNoSelfAgentHints({ daemonConfig: loadDaemonConfig(), ecwebStarted, skipped });
+            }
             return;
         }
         // 超时

package/dist/cli/init.js

@@ -1,4 +1,5 @@
 import fs from 'fs';
+import os from 'os';
 import path from 'path';
 import readline from 'readline';
 import { resolvePaths, ensureDataDirs } from '../paths.js';
@@ -13,6 +14,15 @@ import { WEB_CLI_BIN, WEB_PACKAGE_LATEST } from '../product.js';
 function ask(rl, question) {
     return new Promise(resolve => rl.question(question, resolve));
 }
+/** 展开用户在交互式输入中使用的 home 目录简写（shell 不会替 readline 自动做这件事）。 */
+export function expandLeadingTildePath(value, homeDir = os.homedir()) {
+    if (value === '~')
+        return homeDir;
+    if (value.startsWith('~/') || value.startsWith('~\\')) {
+        return path.join(homeDir, value.slice(2));
+    }
+    return value;
+}
 const BASEAGENT_CANDIDATES = ['claude', 'codex', 'gemini'];
 function isBaseagentAvailable(baseagent) {
     if (baseagent === 'codex')
@@ -167,7 +177,7 @@ export async function cmdInit(options) {
         await runInteractive();
     }
     // ── 共享 tail（单一出口）：提示创建 agent + 生成控制 AID ──
-    await initTail();
+    await initTail({ invokedByStart: options?.invokedByStart });
     // ── 内部函数 ──
     async function runInteractive() {
         const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -194,29 +204,36 @@ export async function cmdInit(options) {
         }
         async function askProjectsDefaultPath() {
             const defaultDir = path.join(defaultProjectsRoot(p.root), 'default');
-            const input = (await ask(rl, `项目默认目录 [${defaultDir}]: `)).trim();
-            const resolved = input || defaultDir;
-            if (!path.isAbsolute(resolved)) {
-                console.log('  ⚠ 需要绝对路径，已跳过');
-                return undefined;
-            }
-            if (!fs.existsSync(resolved)) {
-                const create = (await ask(rl, `  目录不存在，是否创建？[Y/n]: `)).trim().toLowerCase();
-                if (create === '' || create === 'y' || create === 'yes') {
-                    try {
-                        fs.mkdirSync(resolved, { recursive: true });
+            while (true) {
+                const input = (await ask(rl, `项目默认目录 [${defaultDir}]（输入 skip 跳过）: `)).trim();
+                if (input.toLowerCase() === 'skip') {
+                    console.log('  已跳过项目默认目录配置');
+                    return undefined;
+                }
+                const resolved = expandLeadingTildePath(input || defaultDir);
+                if (!path.isAbsolute(resolved)) {
+                    console.log('  ⚠ 请输入绝对路径或回车使用默认值；输入 skip 可跳过');
+                    continue;
+                }
+                if (!fs.existsSync(resolved)) {
+                    const create = (await ask(rl, `  目录不存在，是否创建？[Y/n]: `)).trim().toLowerCase();
+                    if (create === '' || create === 'y' || create === 'yes') {
+                        try {
+                            fs.mkdirSync(resolved, { recursive: true });
+                        }
+                        catch (e) {
+                            console.log(`  ⚠ 创建目录失败: ${e?.message || e}`);
+                            continue;
+                        }
+                        console.log(`  ✓ 已创建 ${resolved}`);
                     }
-                    catch (e) {
-                        console.log(`  ⚠ 创建目录失败: ${e?.message || e}`);
-                        return undefined;
+                    else {
+                        console.log('  未创建目录，请重新输入路径；输入 skip 可跳过');
+                        continue;
                     }
-                    console.log(`  ✓ 已创建 ${resolved}`);
-                }
-                else {
-                    return undefined;
                 }
+                return resolved;
             }
-            return resolved;
         }
         try {
             if (defaultsExisted) {
@@ -249,10 +266,10 @@ export async function cmdInit(options) {
     }
 }
 /** 补全控制 AID + owners（可单独调用，不走 baseagent 向导）。 */
-export async function initTail() {
+export async function initTail(options = {}) {
     // 提示创建 agent（两分支汇合后执行一次）
     const { agents } = loadAllAgents();
-    if (agents.length === 0) {
+    if (agents.length === 0 && !options.invokedByStart) {
         console.log('\n提示：尚无 agent，运行以下命令创建：');
         console.log('  ec agent new <aid>.agentid.pub');
     }
@@ -368,6 +385,9 @@ export async function initTail() {
             }
         }
     }
+    // ec start 会接着启动 daemon，并在其 ready 后给出可用的 Agent 创建入口。
+    if (options.invokedByStart)
+        return;
     // 初始化完成总结
     console.log('\n✓ EvolCore 初始化完成');
     const finalCfg = loadDaemonConfig();

package/dist/config/access-policy-domain.js

@@ -4,18 +4,6 @@ export function validAgentOwnerIds(agent) {
             .map(value => String(value || '').trim())
             .filter(isValidAid))];
 }
-export function configuredChannelKeys(selfAid, agent) {
-    const keys = (agent?.channels ?? [])
-        .filter(channel => channel && channel.enabled !== false)
-        .map(channel => {
-        const type = String(channel.type || '').trim().toLowerCase();
-        const name = String(channel.name || '').trim();
-        return type && name ? `${type}#${selfAid}#${name}` : '';
-    })
-        .filter(Boolean);
-    keys.push(`aun#${selfAid}#main`);
-    return [...new Set(keys)];
-}
 export function validateAccessPolicyDomain(selfAid, agent) {
     const access = agent.access;
     if (!access)
@@ -26,13 +14,5 @@ export function validateAccessPolicyDomain(selfAid, agent) {
             message: `Agent ${selfAid} cannot use ${access.policyMode} without an Owner`,
         };
     }
-    const configured = new Set(configuredChannelKeys(selfAid, agent));
-    const unknown = access.allowedGroupChannels.find(channelKey => !configured.has(channelKey));
-    if (unknown) {
-        return {
-            code: 'unknown_group_access_channel',
-            message: `Group access channel is not configured or enabled for ${selfAid}: ${unknown}`,
-        };
-    }
     return undefined;
 }

package/dist/config/access-policy.js

@@ -1,6 +1,6 @@
 import crypto from 'crypto';
 import { ConfigError, ConfigTarget, mutateConfig, read, validateConfig, } from './config-manager.js';
-import { configuredChannelKeys, validAgentOwnerIds, validateAccessPolicyDomain, } from './access-policy-domain.js';
+import { validAgentOwnerIds, validateAccessPolicyDomain, } from './access-policy-domain.js';
 export class AccessPolicyError extends Error {
     code;
     data;
@@ -13,20 +13,13 @@ export class AccessPolicyError extends Error {
 }
 export const DEFAULT_ACCESS_POLICY = Object.freeze({
     policyMode: 'open',
-    allowedGroupChannels: Object.freeze([]),
     requestLimit: Object.freeze({ maxTimes: 600, coolDown: 60 * 60 }),
 });
 export function listAgentOwners(selfAid) {
     const agent = read(ConfigTarget.Agent, { self: selfAid }, { cache: true });
     return validAgentOwnerIds(agent);
 }
-export function listConfiguredChannelKeys(selfAid) {
-    const agent = read(ConfigTarget.Agent, { self: selfAid }, { cache: true });
-    if (!agent)
-        return [];
-    return configuredChannelKeys(selfAid, agent);
-}
-/** Missing AgentConfig.access uses the compatibility view; malformed Agent config never does. */
+/** Missing AgentConfig.access uses the default open policy; malformed Agent config never does. */
 export function readAccessPolicy(selfAid) {
     return readAccessPolicySnapshot(selfAid).policy;
 }
@@ -49,7 +42,7 @@ export function mutateAccessPolicy(input) {
                 });
             }
             const next = input.update(clonePolicy(current.policy));
-            assertAccessPolicyWrite(input, agent, current.policy, next);
+            assertAccessPolicyWrite(input, agent, next);
             agent.access = clonePolicy(next);
             return {
                 policy: clonePolicy(next),
@@ -85,37 +78,20 @@ function accessPolicySnapshotFromAgent(selfAid, agent) {
     const policy = clonePolicy(access);
     return { policy, accessRevision: accessPolicyRevision(policy) };
 }
-function assertAccessPolicyWrite(input, agent, current, policy) {
+function assertAccessPolicyWrite(input, agent, policy) {
     const owners = validAgentOwnerIds(agent);
     const normalizedActorAid = String(input.actorAid || '').trim();
     const isOwner = input.actorRole === 'owner' || owners.includes(normalizedActorAid);
-    const isGroupChannelAdmin = input.actorRole === 'admin' && input.resource === 'access.allowedGroupChannels';
-    if (!isOwner && !isGroupChannelAdmin) {
-        if (input.resource === 'access.allowedGroupChannels') {
-            throw new AccessPolicyError('access_policy_manager_required', 'Only an Agent Owner or Admin can change allowed group channels');
-        }
+    if (!isOwner) {
         throw new AccessPolicyError('access_policy_owner_required', 'Only an Agent Owner can change access policy');
     }
-    if (isGroupChannelAdmin) {
-        if (current.policyMode !== policy.policyMode
-            || current.requestLimit.maxTimes !== policy.requestLimit.maxTimes
-            || current.requestLimit.coolDown !== policy.requestLimit.coolDown) {
-            throw new AccessPolicyError('access_policy_owner_required', 'An Agent Admin may only change allowed group channels');
-        }
-    }
     if (policy.policyMode !== 'open' && owners.length === 0) {
         throw new AccessPolicyError('restricted_mode_without_owner', `Agent ${input.selfAid} cannot use ${policy.policyMode} without an Owner`);
     }
-    const configured = new Set(configuredChannelKeys(input.selfAid, agent));
-    const unknown = policy.allowedGroupChannels.find(channelKey => !configured.has(channelKey));
-    if (unknown) {
-        throw new AccessPolicyError('unknown_group_access_channel', `Group access channel is not configured or enabled for ${input.selfAid}: ${unknown}`);
-    }
 }
 function clonePolicy(policy) {
     return {
         policyMode: policy.policyMode,
-        allowedGroupChannels: [...policy.allowedGroupChannels],
         requestLimit: { ...policy.requestLimit },
     };
 }

package/dist/core/auth/operation-catalog.js

@@ -397,7 +397,7 @@ const OPERATIONS = [
         category: 'write-agent',
         dangerous: false,
         defaultScopes: ['agent'],
-        description: 'Manage contacts, contact requests, and allowed group channels',
+        description: 'Manage contacts and contact requests',
         sources: ['menu', 'ecweb', 'control'],
     },
     {

package/dist/core/command/connect-menu.js

@@ -1,6 +1,6 @@
-import { roleMenuQuery, roleMenuUpdate, } from './role-menu.js';
+import { roleMenuQuery, roleMenuGroupCount, roleMenuUpdate, } from './role-menu.js';
 import { getContactSnapshot, resolveContactView } from '../../config/contact-book.js';
-import { listConfiguredChannelKeys, mutateAccessPolicy, readAccessPolicySnapshot, } from '../../config/access-policy.js';
+import { mutateAccessPolicy, readAccessPolicySnapshot, } from '../../config/access-policy.js';
 import { expirePendingContactRequests, mutateContactWithOperation, reviewContactRequest, } from '../../config/contact-request-service.js';
 import { formatPeerKey, parsePeerKey } from '../relation/peer-identity.js';
 /**
@@ -13,8 +13,8 @@ import { formatPeerKey, parsePeerKey } from '../relation/peer-identity.js';
  *   群组不落 contact.json（contact book 只接受个人 AID，group 会被拒绝）。
  * - 联系人与申请（view=contacts / contact，add / block / unblock / review）→ 直接读写
  *   Contact Book v3；contact.json 是当前状态和 pending 版本的唯一事实来源。
- * - 访问设置（view=access / option=allowedGroupChannels / resource=<access field>）→
- *   查询策略、列举群聊渠道候选项并逐字段写入 Agent config.json 的 access 字段。
+ * - 访问设置（view=access / resource=<access field>）→
+ *   查询和写入 Agent config.json 的 access 字段。
  */
 const MENU_NAME = 'connect';
 const DEFAULT_PAGE_SIZE = 50;
@@ -31,8 +31,6 @@ export function connectMenuOperation(kind, args, value) {
     if (kind === 'action')
         return 'connect.write';
     const resource = String(args?.resource ?? '');
-    if (resource === 'allowedGroupChannels')
-        return 'connect.write';
     if (resource === 'policyMode' || resource === 'requestLimit') {
         return 'connect.access.write';
     }
@@ -55,7 +53,7 @@ export async function handleConnectMenu(req, context) {
     }
     try {
         if (req.subtype === 'options')
-            return await handleOptions(self, req.args);
+            return await handleOptions(self, req.args, context);
         if (req.subtype === 'query')
             return await handleQuery(req, self, context);
         if (req.subtype === 'update')
@@ -69,26 +67,24 @@ export async function handleConnectMenu(req, context) {
     return fail('INVALID_ARGUMENT', `Unknown subtype: ${req.subtype}`);
 }
 // ── Options ──
-async function handleOptions(self, args) {
+async function handleOptions(self, args, context) {
     const option = String(args?.option ?? '').trim();
     if (option) {
-        if (option !== 'allowedGroupChannels') {
-            return fail('NOT_SUPPORTED', `Unknown connect option: ${option}`);
-        }
-        const selected = new Set(readAccessPolicySnapshot(self).policy.allowedGroupChannels);
-        return ok({
-            options: listConfiguredChannelKeys(self).map(channelKey => ({
-                option: channelKey,
-                label: channelKey,
-                selected: selected.has(channelKey),
-            })),
-        });
+        return fail('NOT_SUPPORTED', `Unknown connect option: ${option}`);
     }
     await expirePendingContactRequests(self);
     const snapshot = getContactSnapshot(self);
     const contactCount = snapshot.contacts.size;
     const blockedCount = snapshot.blockedIndex.size;
     const pendingCount = [...snapshot.contacts.values()].filter(entry => entry.status === 'pending').length;
+    let groupsDescription = '查看所在群组（数量暂不可用）';
+    try {
+        const groupCount = await roleMenuGroupCount(context);
+        groupsDescription = `查看所在群组（${groupCount} 个）`;
+    }
+    catch {
+        // Keep the root menu available when AUN group directory is disabled or unavailable.
+    }
     return ok({
         options: [
             {
@@ -99,12 +95,12 @@ async function handleOptions(self, args) {
             {
                 option: 'groups',
                 label: '群组列表',
-                description: '查看所在群组',
+                description: groupsDescription,
             },
             {
                 option: 'access',
                 label: '访问设置',
-                description: '设置私聊准入模式与允许群聊的渠道',
+                description: '设置消息准入模式和准入控制消息限额',
             },
         ],
     });
@@ -268,15 +264,11 @@ async function handleAction(req, self, context) {
 }
 function isAccessUpdateResource(resource) {
     return resource === 'policyMode'
-        || resource === 'allowedGroupChannels'
         || resource === 'requestLimit';
 }
 function updateAccessResource(req, context, resource) {
     const args = req.args ?? {};
-    if (resource === 'allowedGroupChannels')
-        requireAdminContext(context);
-    else
-        requireOwnerContext(context);
+    requireOwnerContext(context);
     if (req.value === undefined || !req.value.trim()) {
         return fail('INVALID_ARGUMENT', 'value is required');
     }
@@ -284,15 +276,8 @@ function updateAccessResource(req, context, resource) {
     const expectedAccessRevision = requireAccessRevision(args);
     const decoded = decodeAccessUpdateValue(req.value);
     if (resource === 'policyMode') {
-        if (typeof decoded !== 'string' || !['open', 'contacts', 'owners-only'].includes(decoded)) {
-            return fail('INVALID_ARGUMENT', 'policyMode must be open, contacts, or owners-only');
-        }
-    }
-    else if (resource === 'allowedGroupChannels') {
-        if (!Array.isArray(decoded)
-            || !decoded.every(value => typeof value === 'string' && value.length > 0)
-            || new Set(decoded).size !== decoded.length) {
-            return fail('INVALID_ARGUMENT', 'allowedGroupChannels must be a JSON string array');
+        if (typeof decoded !== 'string' || !['open', 'contacts', 'owners'].includes(decoded)) {
+            return fail('INVALID_ARGUMENT', 'policyMode must be open, contacts, or owners');
         }
     }
     else {
@@ -452,16 +437,12 @@ function errorCode(error) {
         return 'INTERNAL_ERROR';
     if (code === 'access_policy_owner_required')
         return 'PERMISSION_DENIED';
-    if (code === 'access_policy_manager_required')
-        return 'PERMISSION_DENIED';
     if (code === 'access_policy_revision_conflict')
         return 'CONFLICT';
     if (code === 'access_policy_temporarily_unavailable')
         return 'TEMPORARILY_UNAVAILABLE';
     if (code === 'restricted_mode_without_owner')
         return 'NOT_ALLOWED';
-    if (code === 'unknown_group_access_channel')
-        return 'INVALID_ARGUMENT';
     if (code === 'invalid_access_policy')
         return 'INTERNAL_ERROR';
     return typeof code === 'string' ? code : 'INTERNAL_ERROR';
@@ -538,9 +519,6 @@ function accessPolicyWithUpdate(current, resource, decoded) {
     if (resource === 'policyMode') {
         return { ...current, policyMode: decoded };
     }
-    if (resource === 'allowedGroupChannels') {
-        return { ...current, allowedGroupChannels: [...decoded] };
-    }
     const requestLimit = decoded;
     return {
         ...current,

package/dist/core/command/role-menu.js

@@ -156,6 +156,22 @@ export async function roleMenuQuery(context, args) {
         view: view || null,
     });
 }
+/**
+ * Read the current joined-group count without materializing the full group list.
+ * Used by Connect's root options description; failures are handled by the caller
+ * so a transient AUN directory outage does not hide the rest of the menu.
+ */
+export async function roleMenuGroupCount(context) {
+    assertRequest(context, { self: context.self });
+    assertAunDirectory(context);
+    const result = await roleDirectory(context).listGroups({ from: context.self, size: 1 });
+    if (!result.ok) {
+        throw roleError('TEMPORARILY_UNAVAILABLE', result.error || 'Unable to list joined groups', context.self, {
+            kind: 'target_source_unavailable', targetType: 'group',
+        });
+    }
+    return Math.max(Number(result.total) || 0, result.items.length);
+}
 export async function roleMenuUpdate(context, args, rawValue) {
     assertRequest(context, args);
     const value = parseUpdateValue(rawValue, context.self);

package/dist/core/message/inbound-admission.js

@@ -44,6 +44,23 @@ export function evaluateInboundAdmissionPreflight(input) {
             }
         }
     }
+    else {
+        // Group admission is based on group membership in `contacts` mode, but
+        // owners mode still needs to identify an Owner sender. Resolve only the
+        // canonical identity needed for that distinction; group messages do not
+        // use contact status or private-channel blocking rules.
+        try {
+            const principal = resolvePrincipal(selfAid, channelType, actorId, input.channelKey);
+            if (principal.principalId) {
+                context.primaryId = principal.principalId;
+                context.isOwner = resolveContactView(selfAid, principal.principalId).isOwner;
+            }
+        }
+        catch {
+            // Open/contacts group admission remains membership-based even when a
+            // native identity cannot be resolved through the contact book.
+        }
+    }
     try {
         context.policy = readAccessPolicy(selfAid);
     }
@@ -62,26 +79,19 @@ export function evaluateOrdinaryInboundAdmission(context) {
     if (!policy)
         return { allow: false, reason: 'invalid_access_policy', context };
     if (context.chatType === 'group') {
-        if (policy.policyMode === 'owners-only') {
-            return { allow: false, reason: 'owners_only', context };
-        }
-        // `open` is genuinely open: group traffic is not gated by the optional
-        // channel allow-list. In `contacts`, AUN groups are currently open once
-        // the agent is receiving that group; non-AUN channels remain explicit.
-        if (policy.policyMode === 'open'
-            || (policy.policyMode === 'contacts' && context.channelType === 'aun')) {
+        if (context.isOwner)
+            return { allow: true, reason: 'owner', context };
+        if (policy.policyMode === 'open' || policy.policyMode === 'contacts') {
             return { allow: true, reason: 'group_channel_allowed', context };
         }
-        return policy.allowedGroupChannels.includes(context.channelKey)
-            ? { allow: true, reason: 'group_channel_allowed', context }
-            : { allow: false, reason: 'group_channel_denied', context };
+        return { allow: false, reason: 'owners', context };
     }
     if (context.isOwner)
         return { allow: true, reason: 'owner', context };
     if (policy.policyMode === 'open')
         return { allow: true, reason: 'open', context };
-    if (policy.policyMode === 'owners-only')
-        return { allow: false, reason: 'owners_only', context };
+    if (policy.policyMode === 'owners')
+        return { allow: false, reason: 'owners', context };
     if (context.primaryId && isAcceptedContact(context.selfAid, context.primaryId)) {
         return { allow: true, reason: 'contact', context };
     }

package/dist/core/session/session-fs-store.js

@@ -10,15 +10,25 @@ function encodeSegment(s) {
 function decodeSegment(s) {
     return s.replace(/%([0-9A-Fa-f]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
 }
+function resolveAunSelfAID(selfAID, channelKey) {
+    const direct = selfAID?.trim();
+    if (direct && direct !== '_unknown')
+        return direct;
+    const parts = channelKey?.split('#');
+    const inferred = parts?.length === 3 && parts[0] === 'aun' ? parts[1]?.trim() : undefined;
+    if (inferred && inferred !== '_unknown')
+        return inferred;
+    throw new Error('[SessionFsStore] AUN chat directory requires selfAID or an aun channel key.');
+}
 /**
  * 计算 chat 目录的完整路径。
- * - aun: sessionsDir/aun/<urlEncode(selfAID|'_unknown')>/<urlEncode(channelId)>/
+ * - aun: sessionsDir/aun/<urlEncode(selfAID)>/<urlEncode(channelId)>/
  * - wecom: sessionsDir/wecom/<urlEncode(channelKey)>/<urlEncode(channelId)>/
  * - 其它: sessionsDir/<channelType>/<urlEncode(channelId)>/
  */
 export function chatDirPath(sessionsDir, channelType, channelId, selfAID, channelKey) {
     if (channelType === 'aun') {
-        return path.join(sessionsDir, channelType, encodeSegment(selfAID || '_unknown'), encodeSegment(channelId));
+        return path.join(sessionsDir, channelType, encodeSegment(resolveAunSelfAID(selfAID, channelKey)), encodeSegment(channelId));
     }
     if (channelType === 'wecom' && channelKey?.startsWith('wecom#')) {
         return path.join(sessionsDir, channelType, encodeSegment(channelKey), encodeSegment(channelId));
@@ -47,9 +57,8 @@ export function formatTimestamp(epochMs) {
     const ss = String(d.getSeconds()).padStart(2, '0');
     return `${yyyy}-${mo}-${dd} ${hh}:${mi}:${ss}`;
 }
-export function atomicWriteJson(filePath, data) {
+function atomicWrite(filePath, content) {
     const tmpPath = filePath + '.tmp';
-    const content = JSON.stringify(data, null, 2) + '\n';
     const fd = fs.openSync(tmpPath, 'w');
     fs.writeSync(fd, content);
     fs.fsyncSync(fd);
@@ -63,6 +72,12 @@ export function atomicWriteJson(filePath, data) {
     }
     fs.renameSync(tmpPath, filePath);
 }
+export function atomicWriteJson(filePath, data) {
+    atomicWrite(filePath, JSON.stringify(data, null, 2) + '\n');
+}
+export function atomicWriteText(filePath, content) {
+    atomicWrite(filePath, content);
+}
 export function appendJsonl(filePath, record) {
     const line = JSON.stringify(record) + '\n';
     const fd = fs.openSync(filePath, 'a');

package/dist/core/session/session-manager.js

@@ -1,7 +1,7 @@
 import { ensureDir } from '../../utils/atomic-write.js';
 import { logger } from '../../utils/logger.js';
 import { encodePath } from '../../utils/cross-platform.js';
-import { chatDirPath, generateSessionId, formatTimestamp, atomicWriteJson, appendJsonl, readJsonFile, readLastJsonlLine, readAllJsonlLines, scanChatDirs, scanMetaFiles, ensureChatDir, readThreadIndex, writeThreadIndex, } from './session-fs-store.js';
+import { chatDirPath, generateSessionId, formatTimestamp, atomicWriteJson, atomicWriteText, appendJsonl, readJsonFile, readLastJsonlLine, readAllJsonlLines, scanChatDirs, scanMetaFiles, ensureChatDir, readThreadIndex, writeThreadIndex, } from './session-fs-store.js';
 import { sessionToFile, fileToSession } from './session-mapper.js';
 import { formatSessionKey, DEFAULT_THREAD_ID } from './session-key.js';
 import { tryParseChannelKey } from '../channel-loader.js';
@@ -39,6 +39,7 @@ export class SessionManager {
         this.eventBus = eventBus;
         this.identityResolver = identityResolver;
         this.migrateChannelKeyFormat();
+        this.migrateUnknownAunDirs();
         this.migrateWecomChannelDirs();
     }
     setIdentityResolver(resolver) {
@@ -1662,4 +1663,209 @@ export class SessionManager {
             logger.info(`[SessionManager] Migrated ${migrated} WeCom session director${migrated === 1 ? 'y' : 'ies'} to channelKey isolation`);
         }
     }
+    /**
+     * Recover legacy AUN chats written beneath `_unknown` before selfAID was
+     * persisted. A channel key or persisted selfAID is required to make the
+     * migration unambiguous; all other directories remain untouched.
+     */
+    migrateUnknownAunDirs() {
+        const legacyDirs = scanChatDirs(this.sessionsDir)
+            .filter(entry => entry.channelType === 'aun' && entry.selfAID === '_unknown');
+        let migrated = 0;
+        for (const entry of legacyDirs) {
+            const selfAIDs = this.findAunSelfAIDCandidates(entry.dirPath);
+            if (selfAIDs.size !== 1) {
+                if (selfAIDs.size > 1) {
+                    logger.error(`[SessionManager] Cannot auto-migrate mixed unknown AUN session directory: ${entry.dirPath}`);
+                }
+                continue;
+            }
+            const selfAID = [...selfAIDs][0];
+            const target = chatDirPath(this.sessionsDir, 'aun', entry.channelId, selfAID);
+            try {
+                this.mergeUnknownAunDirectory(entry.dirPath, target, selfAID);
+                migrated++;
+            }
+            catch (error) {
+                logger.error(`[SessionManager] Failed to migrate unknown AUN session directory ${entry.dirPath}: ${String(error)}`);
+            }
+        }
+        if (migrated > 0) {
+            logger.info(`[SessionManager] Migrated ${migrated} unknown AUN session director${migrated === 1 ? 'y' : 'ies'} to selfAID isolation`);
+        }
+    }
+    findAunSelfAIDCandidates(chatDir) {
+        const candidates = new Set();
+        const visitRecord = (record) => {
+            if (!record || typeof record !== 'object')
+                return;
+            const session = record;
+            const direct = typeof session.selfAID === 'string' ? session.selfAID.trim() : '';
+            if (direct && direct !== '_unknown')
+                candidates.add(direct);
+            const channel = typeof session.channel === 'string' ? tryParseChannelKey(session.channel) : null;
+            if (channel?.type === 'aun' && channel.selfAID !== '_unknown')
+                candidates.add(channel.selfAID);
+        };
+        const visitJsonl = (filePath) => {
+            for (const record of readAllJsonlLines(filePath))
+                visitRecord(record);
+        };
+        visitRecord(readJsonFile(path.join(chatDir, 'active.json')));
+        for (const metaFile of scanMetaFiles(chatDir))
+            visitJsonl(path.join(chatDir, metaFile));
+        const threadDir = path.join(chatDir, '_threads');
+        for (const metaFile of scanMetaFiles(threadDir))
+            visitJsonl(path.join(threadDir, metaFile));
+        return candidates;
+    }
+    mergeUnknownAunDirectory(sourceDir, targetDir, selfAID) {
+        if (sourceDir === targetDir)
+            return;
+        fs.mkdirSync(targetDir, { recursive: true });
+        this.mergeUnknownAunDirectoryContents(sourceDir, targetDir, selfAID);
+        fs.rmdirSync(sourceDir);
+    }
+    mergeUnknownAunDirectoryContents(sourceDir, targetDir, selfAID) {
+        for (const entry of fs.readdirSync(sourceDir, { withFileTypes: true })) {
+            const sourcePath = path.join(sourceDir, entry.name);
+            const targetPath = path.join(targetDir, entry.name);
+            if (entry.isDirectory()) {
+                fs.mkdirSync(targetPath, { recursive: true });
+                this.mergeUnknownAunDirectoryContents(sourcePath, targetPath, selfAID);
+                fs.rmdirSync(sourcePath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (entry.name === 'active.json') {
+                this.mergeUnknownAunActiveFile(sourcePath, targetPath, selfAID);
+            }
+            else if (entry.name.endsWith('.jsonl')) {
+                this.mergeUnknownAunJsonlFile(sourcePath, targetPath, selfAID);
+            }
+            else if (entry.name.endsWith('.json')) {
+                this.mergeUnknownAunJsonFile(sourcePath, targetPath);
+            }
+            else if (!fs.existsSync(targetPath)) {
+                fs.renameSync(sourcePath, targetPath);
+            }
+            else if (fs.readFileSync(sourcePath).equals(fs.readFileSync(targetPath))) {
+                fs.unlinkSync(sourcePath);
+            }
+            else {
+                fs.renameSync(sourcePath, this.uniqueLegacyFilePath(targetPath));
+            }
+        }
+    }
+    mergeUnknownAunActiveFile(sourcePath, targetPath, selfAID) {
+        const source = this.normalizeAunSessionRecord(readJsonFile(sourcePath), selfAID);
+        const target = this.normalizeAunSessionRecord(readJsonFile(targetPath), selfAID);
+        const sourceUpdatedAt = typeof source?.updatedAt === 'number' ? source.updatedAt : 0;
+        const targetUpdatedAt = typeof target?.updatedAt === 'number' ? target.updatedAt : 0;
+        const selected = target && targetUpdatedAt >= sourceUpdatedAt ? target : source;
+        if (selected)
+            atomicWriteJson(targetPath, selected);
+        fs.unlinkSync(sourcePath);
+    }
+    mergeUnknownAunJsonlFile(sourcePath, targetPath, selfAID) {
+        const records = [
+            ...this.readNormalizedAunJsonl(sourcePath, selfAID),
+            ...this.readNormalizedAunJsonl(targetPath, selfAID),
+        ];
+        const seen = new Set();
+        const unique = records.filter(record => {
+            if (seen.has(record.key))
+                return false;
+            seen.add(record.key);
+            return true;
+        });
+        unique.sort((left, right) => left.timestamp - right.timestamp || left.order - right.order);
+        atomicWriteText(targetPath, unique.map(record => record.line).join('\n') + (unique.length ? '\n' : ''));
+        fs.unlinkSync(sourcePath);
+    }
+    readNormalizedAunJsonl(filePath, selfAID) {
+        let content;
+        try {
+            content = fs.readFileSync(filePath, 'utf-8');
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+        return content.split('\n').flatMap((rawLine, order) => {
+            const line = rawLine.trim();
+            if (!line)
+                return [];
+            try {
+                const record = this.normalizeAunSessionRecord(JSON.parse(line), selfAID);
+                const normalizedLine = JSON.stringify(record);
+                return [{
+                        key: this.stableJson(record),
+                        line: normalizedLine,
+                        timestamp: this.recordTimestamp(record),
+                        order,
+                    }];
+            }
+            catch {
+                return [{ key: `raw:${line}`, line, timestamp: Number.MAX_SAFE_INTEGER, order }];
+            }
+        });
+    }
+    normalizeAunSessionRecord(record, selfAID) {
+        if (!record || typeof record !== 'object' || Array.isArray(record))
+            return record;
+        const result = { ...record };
+        const isSessionRecord = 'channel' in result || 'channelType' in result || 'sessionKey' in result || 'selfAID' in result;
+        if (!isSessionRecord)
+            return result;
+        if (!result.selfAID || result.selfAID === '_unknown')
+            result.selfAID = selfAID;
+        return result;
+    }
+    stableJson(value) {
+        if (Array.isArray(value))
+            return `[${value.map(item => this.stableJson(item)).join(',')}]`;
+        if (value && typeof value === 'object') {
+            return `{${Object.keys(value).sort().map(key => `${JSON.stringify(key)}:${this.stableJson(value[key])}`).join(',')}}`;
+        }
+        return JSON.stringify(value);
+    }
+    recordTimestamp(record) {
+        if (!record || typeof record !== 'object')
+            return Number.MAX_SAFE_INTEGER;
+        const value = record;
+        for (const key of ['ts', 'at', 'updatedAt', 'createdAt']) {
+            if (typeof value[key] === 'number' && Number.isFinite(value[key]))
+                return value[key];
+        }
+        return Number.MAX_SAFE_INTEGER;
+    }
+    mergeUnknownAunJsonFile(sourcePath, targetPath) {
+        if (!fs.existsSync(targetPath)) {
+            fs.renameSync(sourcePath, targetPath);
+            return;
+        }
+        const source = readJsonFile(sourcePath);
+        const target = readJsonFile(targetPath);
+        if (source && target && !Array.isArray(source) && !Array.isArray(target)) {
+            atomicWriteJson(targetPath, { ...source, ...target });
+            fs.unlinkSync(sourcePath);
+            return;
+        }
+        if (fs.readFileSync(sourcePath).equals(fs.readFileSync(targetPath))) {
+            fs.unlinkSync(sourcePath);
+            return;
+        }
+        fs.renameSync(sourcePath, this.uniqueLegacyFilePath(targetPath));
+    }
+    uniqueLegacyFilePath(targetPath) {
+        let index = 1;
+        let candidate = `${targetPath}.legacy-unknown`;
+        while (fs.existsSync(candidate)) {
+            candidate = `${targetPath}.legacy-unknown-${index++}`;
+        }
+        return candidate;
+    }
 }

package/dist/utils/cross-platform.js

@@ -3,6 +3,7 @@ import { fileURLToPath } from 'url';
 import { execFileSync, execFile, spawn, spawnSync } from 'child_process';
 import { promisify } from 'util';
 import fs from 'fs';
+import { getProcessStartTime } from './process-introspect.js';
 const execFileAsync = promisify(execFile);
 export const isWindows = process.platform === 'win32';
 const ENCODE_PATH_MAX = 200;
@@ -133,10 +134,15 @@ export function getProcessInfo(pid) {
             }
         }
         else {
-            const etimes = execFileSync('ps', ['-p', String(pid), '-o', 'etimes='], { encoding: 'utf-8' }).trim();
+            // procps `etimes` can overflow for freshly spawned processes in some
+            // container/time-namespace combinations. /proc start time is reliable
+            // on Linux and is already used for PID reuse protection elsewhere.
+            const startedAt = process.platform === 'linux' ? getProcessStartTime(pid) : null;
+            const uptime = startedAt !== null
+                ? formatUptime(Math.max(0, Math.floor((Date.now() - startedAt) / 1000)))
+                : formatUptime(parseInt(execFileSync('ps', ['-p', String(pid), '-o', 'etimes='], { encoding: 'utf-8' }).trim(), 10));
             const cpu = execFileSync('ps', ['-p', String(pid), '-o', '%cpu='], { encoding: 'utf-8' }).trim();
             const mem = execFileSync('ps', ['-p', String(pid), '-o', 'rss='], { encoding: 'utf-8' }).trim();
-            const uptime = formatUptime(parseInt(etimes, 10));
             return { uptime, cpu, memory: mem };
         }
     }

package/dist/utils/process-introspect.js

@@ -8,8 +8,25 @@
  */
 import fs from 'fs';
 import { spawnSync } from 'child_process';
-import { isWindows } from './cross-platform.js';
+const isWindows = process.platform === 'win32';
 const isMacOS = process.platform === 'darwin';
+function readLinuxClockTicks() {
+    if (process.platform !== 'linux')
+        return 100;
+    try {
+        const result = spawnSync('getconf', ['CLK_TCK'], {
+            encoding: 'utf-8',
+            timeout: 1000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const value = Number.parseInt(result.stdout?.trim() || '', 10);
+        return value > 0 ? value : 100;
+    }
+    catch {
+        return 100;
+    }
+}
+const linuxClockTicks = readLinuxClockTicks();
 /** 容差：2 秒（覆盖 macOS 秒级精度 + 时钟漂移） */
 export const START_TIME_TOLERANCE_MS = 2000;
 /**
@@ -72,8 +89,7 @@ function getStartTimeLinux(pid) {
     }
     if (isNaN(btimeSec))
         return null;
-    const clkTck = 100;
-    return (btimeSec + starttimeJiffies / clkTck) * 1000;
+    return (btimeSec + starttimeJiffies / linuxClockTicks) * 1000;
 }
 // ── macOS ──
 function getStartTimeMacOS(pid) {

package/kits/docs/evolcore/config.md

@@ -134,15 +134,15 @@ ConfigManager 只合并上述物理层并返回物理来源。角色策略不进
 {
   "access": {
     "policyMode": "contacts",
-    "allowedGroupChannels": [],
     "requestLimit": { "maxTimes": 600, "coolDown": 3600 }
   }
 }
 ```
 
-`policyMode` 为 `open | contacts | owners-only`；`allowedGroupChannels` 使用完整渠道实例键，空数组表示
-关闭全部群聊渠道；`coolDown` 单位为秒。该对象由 Connect 的访问设置入口整体修改并与 Agent Owner、
-已启用渠道实例共同校验，不通过通用 relation/defaults 覆盖链放宽。
+`policyMode` 为 `open | contacts | owners`；`open` 对所有已配置渠道的私聊和群聊入站开放，`contacts`
+将 Agent 已加入并接收到的群聊视为授权，`owners` 仅 Owner 消息开放；群聊成员不按 Contact Book 联系人
+状态逐一过滤。`requestLimit` 只限制准入控制消息的自动回复、申请和绑定码提示，不是渠道准入开关；`coolDown`
+单位为秒。该对象由 Connect 的访问设置入口修改，不通过通用 relation/defaults 覆盖链放宽。
 
 ### AUN 群规则加载策略
 

package/kits/docs/evolcore/contact.md

@@ -56,6 +56,7 @@ ec contact list --blocked --self <agent-aid>
 ## 拉黑后的消息行为
 
 - AUN 和已绑定外部私聊身份的入站在 MessageBridge 业务入口被拦截，不进入 menu/auth/command/session/queue/LLM。
-- 群聊不按成员的联系人状态过滤，只由 Agent 的 `access.allowedGroupChannels` 和 `policyMode` 决定。
+- 群聊不按成员的联系人状态过滤；`open` 对所有已配置渠道的群聊入站开放，`contacts` 将 Agent 已加入并
+  接收到的群聊视为授权，`owners` 仅 Owner 消息开放。
 - 对 `ai`、`bot`、`agent`、`service` 类型的私聊对端，可限频返回 `[rejection] Not accepting messages from you.`。
 - 入站正文中的 `[rejection]` 没有协议控制语义。发送者未被本 Agent 拉黑时，该文本正常进入响应式会话。

package/kits/schemas/agent-config.schema.9.json

@@ -95,7 +95,6 @@
       "additionalProperties": false,
       "required": [
         "policyMode",
-        "allowedGroupChannels",
         "requestLimit"
       ],
       "properties": {
@@ -104,18 +103,9 @@
           "enum": [
             "open",
             "contacts",
-            "owners-only"
+            "owners"
           ],
-          "description": "私聊准入策略：开放、仅联系人和 Owner、或仅 Owner。"
-        },
-        "allowedGroupChannels": {
-          "type": "array",
-          "items": {
-            "type": "string",
-            "minLength": 1
-          },
-          "uniqueItems": true,
-          "description": "允许群消息进入的完整渠道实例键；空数组表示关闭所有群聊渠道。"
+          "description": "私聊和群聊准入策略：开放、仅联系人或仅 Owner。"
         },
         "requestLimit": {
           "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evolcore",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "AI Agent gateway connecting multiple backends (Claude, Codex, Gemini) to messaging channels (Feishu, WeChat, AUN, QQ) with multi-project session management",
   "type": "module",
   "main": "dist/index.js",