evolcore 0.0.35 → 0.0.37

package/dist/core/thread/topic-id.js

@@ -0,0 +1,248 @@
+/**
+ * 话题身份。
+ *
+ * 话题是双边的：同一个话题在本端和对端各有一个会话。话题在创建时获得一个
+ * 双方共享的全局唯一 id（`thread-…`），因此 id 自身就能定位话题。主话题没有
+ * 创建动作、没有生成 id，它的身份完全由"本端 + 对端"这条关系决定，所以用
+ * 两个 AID 拼成一个与话题并列的 id：
+ *
+ *     main:<aidA>:<aidB>
+ *
+ * 两端各自算出的字符串必须一致，因此格式化时按字典序排序；解析时两种顺序
+ * 都接受并归一到规范顺序，即 `main:<对端>:<本端>` 与 `main:<本端>:<对端>`
+ * 等价。
+ *
+ * 主话题 id 是**身份**，不是线上字段：信封本身已钉死收发双方，发出去只会让
+ * 对端凭空建出一个叫 `main:…` 的话题。它只用于本端寻址、持久化与展示。
+ */
+export const MAIN_TOPIC_PREFIX = 'main:';
+/**
+ * AID 段：不含 `:` 与 `/`，至少两级域名。
+ *
+ * 不能用 `isValidAid`：它要求三级以上，而群 AID（`g-xxx.agentid.cn`）只有两级。
+ * 话题的对端既可能是私聊 AID 也可能是群 AID，这里只做结构校验。
+ */
+function isTopicAidSegment(value) {
+    const labels = value.split('.');
+    if (labels.length < 2)
+        return false;
+    return labels.every(label => /^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/.test(label));
+}
+/** 统一输入形态：去空白与 `@` 前缀。不做域名展开、不改大小写。 */
+export function normalizeTopicAid(value) {
+    return String(value ?? '').trim().replace(/^@/, '');
+}
+/**
+ * 由关系两端生成规范主话题 id。
+ *
+ * 排序保证两端独立计算得到同一个字符串；这也是"换个位置就一致"的实现方式，
+ * 而不是依赖调用方传对顺序。
+ */
+export function formatMainTopicId(aidA, aidB) {
+    const a = normalizeTopicAid(aidA);
+    const b = normalizeTopicAid(aidB);
+    if (!isTopicAidSegment(a) || !isTopicAidSegment(b)) {
+        throw new Error(`Invalid AID for main topic: ${JSON.stringify(aidA)}, ${JSON.stringify(aidB)}`);
+    }
+    const [lo, hi] = a <= b ? [a, b] : [b, a];
+    return `${MAIN_TOPIC_PREFIX}${lo}:${hi}`;
+}
+export function isMainTopicId(value) {
+    if (typeof value !== 'string' || !value.startsWith(MAIN_TOPIC_PREFIX))
+        return false;
+    const parts = value.slice(MAIN_TOPIC_PREFIX.length).split(':');
+    return parts.length === 2 && parts.every(isTopicAidSegment);
+}
+/** 解析主话题 id；两种书写顺序都接受，返回去重后的两端（不保证顺序）。 */
+export function parseMainTopicId(value) {
+    if (!isMainTopicId(value))
+        return undefined;
+    const [aidA, aidB] = value.slice(MAIN_TOPIC_PREFIX.length).split(':');
+    return { aidA, aidB };
+}
+/**
+ * 主话题 id 是否属于 `self`，是则返回对端。
+ *
+ * 这是主话题唯一的合法性判据：会话两端之外的人拿到这个 id 必须失败关闭，
+ * 不能"猜一个对端"。
+ */
+export function mainTopicPeer(topicId, selfAid) {
+    const parsed = parseMainTopicId(topicId);
+    if (!parsed)
+        return undefined;
+    const self = normalizeTopicAid(selfAid);
+    if (parsed.aidA === self)
+        return parsed.aidB;
+    if (parsed.aidB === self)
+        return parsed.aidA;
+    return undefined;
+}
+/** 校验并归一到规范顺序；不是主话题 id 或含非法段时返回 undefined。 */
+export function canonicalizeMainTopicId(value) {
+    const parsed = parseMainTopicId(value);
+    if (!parsed)
+        return undefined;
+    return formatMainTopicId(parsed.aidA, parsed.aidB);
+}
+/**
+ * 宽松版：任一侧不是合法 AID 段时返回 undefined 而不是抛错。
+ *
+ * 会话文件读取路径会碰到内部对端（`bg:` / `trigger:` / `daemon:` 等）与
+ * 非 AUN 渠道，那里不能因为拼不出主话题 id 就中断读取。
+ */
+export function safeFormatMainTopicId(aidA, aidB) {
+    if (!aidA || !aidB)
+        return undefined;
+    try {
+        return formatMainTopicId(aidA, aidB);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * 该 threadId 是否表示"主话题"（本端会话视角）。
+ *
+ * `''` 是历史落盘形态，`'main'` 是更早的哨兵值，`main:<a>:<b>` 是现行规范形态。
+ * 三者都表示主话题；任何需要区分"主话题 / 话题"的地方都必须用它，不能再用
+ * 真假判断——规范形态非空，真假判断会把主话题当成话题。
+ */
+export function isMainSessionThreadId(value) {
+    if (value === undefined || value === null || value === '')
+        return true;
+    if (typeof value !== 'string')
+        return false;
+    return value === 'main' || isMainTopicId(value);
+}
+/** 该 threadId 是否表示话题（真正独立的话题会话）。同时作为类型谓词使用。 */
+export function isTopicThreadId(value) {
+    return typeof value === 'string' && value !== '' && !isMainSessionThreadId(value);
+}
+/** 别名：旧代码中广泛使用的 isSubTopicThreadId，语义与 isTopicThreadId 完全一致。 */
+export const isSubTopicThreadId = isTopicThreadId;
+/**
+ * 把任意 threadId 形态（`''` / null / `'main'` / `main:<a>:<b>` / 话题 id）归一。
+ *
+ * `selfAid` / `peerId` 用于给历史形态（空串、`'main'`）补出规范主话题 id；
+ * 原值已是规范主话题 id 时以原值为准（归一到规范顺序）。
+ */
+export function classifyThreadId(value, selfAid, peerId) {
+    if (isTopicThreadId(value))
+        return { kind: 'topic', threadId: value };
+    if (typeof value === 'string' && isMainTopicId(value)) {
+        return { kind: 'main', topicId: canonicalizeMainTopicId(value) };
+    }
+    return { kind: 'main', topicId: safeFormatMainTopicId(selfAid, peerId) };
+}
+/** switch 穷尽兜底：新增 kind 而调用方未处理时编译失败。 */
+export function assertNeverThreadKind(value) {
+    throw new Error(`Unhandled thread kind: ${JSON.stringify(value)}`);
+}
+export function sessionThreadKind(session) {
+    return classifyThreadId(session.rawThreadId, session.selfAID, session.channelId);
+}
+/** 话题会话返回话题 id，主会话返回 undefined。用于线上 thread_id、话题屏障、getThreadSession 等话题专属路径。 */
+export function sessionTopicThreadId(session) {
+    if (!session)
+        return undefined;
+    const k = sessionThreadKind(session);
+    return k.kind === 'topic' ? k.threadId : undefined;
+}
+/** 本端身份：话题返回话题 id，主会话返回规范主话题 id（拼不出时 undefined）。用于日志、展示、localTopicId。 */
+export function sessionLocalTopicId(session) {
+    if (!session)
+        return undefined;
+    const k = sessionThreadKind(session);
+    return k.kind === 'topic' ? k.threadId : k.topicId;
+}
+// 两者都返回 boolean 而非类型谓词：谓词会把 false 分支收窄成 never，
+// 而"不是话题"的会话仍是会话。需要非空收窄时调用方自己写 `s && isMainSession(s)`。
+export function isTopicSession(session) {
+    return sessionTopicThreadId(session) !== undefined;
+}
+/** 非空且为主会话。session 为空时返回 false（不是"话题"也不是"主会话"）。 */
+export function isMainSession(session) {
+    return !!session && !isTopicSession(session);
+}
+/**
+ * 解析话题引用。
+ *
+ * 规范形态只有两种：`main:<aid>:<aid>` 与裸 `thread-…`。
+ * 裸 `main` 一律拒绝——没有对端就无法确定发给谁，系统不做"默认当前对端"的补全。
+ * 历史写法 `<peer>/<id>` 仍可解析（它已在多处命令中存在），但主话题的
+ * `<peer>/main` 从未实现过，直接拒绝并指向新形态。
+ *
+ * 裸值是按形态区分的：形如 AID（至少两级、只含域名安全字符）的值视为**主话题的对端**，
+ * 解析成 `main:<该AID>:<self>`；其他裸值是话题 id。这个歧义无法彻底消除，但两种
+ * 形态的字符集不重叠（话题 id 是 `thread-…`，不含点），按 AID 结构判断是安全的。
+ */
+export function resolveThreadRef(ref, selfAid) {
+    const raw = String(ref ?? '').trim();
+    if (!raw)
+        return { kind: 'current' };
+    if (raw === 'current')
+        return { kind: 'current' };
+    if (isMainTopicId(raw)) {
+        const peer = mainTopicPeer(raw, selfAid);
+        if (!peer) {
+            return {
+                kind: 'invalid',
+                error: `主话题 ${raw} 不属于当前本端 ${normalizeTopicAid(selfAid)}——主话题 id 由本端与对端共同构成`,
+            };
+        }
+        const topicId = canonicalizeMainTopicId(raw) ?? raw;
+        return { kind: 'main', topicId, peer };
+    }
+    if (raw === 'main') {
+        return {
+            kind: 'invalid',
+            error: '裸 main 不是可用的话题 id：主话题必须写明双方，形如 main:<对端AID>:<本端AID>',
+        };
+    }
+    const slash = raw.lastIndexOf('/');
+    if (slash >= 0) {
+        const peer = raw.slice(0, slash);
+        const rest = raw.slice(slash + 1);
+        if (rest === 'main') {
+            return {
+                kind: 'invalid',
+                error: `<对端>/main 不是话题 id：主话题请用 main:<对端AID>:<本端AID>（如 ec thread list 输出所示）`,
+            };
+        }
+        if (!peer || !rest) {
+            return { kind: 'invalid', error: `无效的话题引用: ${raw}` };
+        }
+        return { kind: 'thread', threadId: rest, peer };
+    }
+    // 裸对端 AID → 该关系的主话题（`ec thread rename <peer>` 等历史写法的语义）。
+    // self 缺失时无法拼出主话题 id，仍按话题 id 处理，由调用方报"不存在"。
+    const self = normalizeTopicAid(selfAid);
+    if (self && isTopicAidSegment(raw)) {
+        const topicId = formatMainTopicId(self, raw);
+        return { kind: 'main', topicId, peer: raw };
+    }
+    return { kind: 'thread', threadId: raw };
+}
+/**
+ * history 类命令 `--thread` 值的归一：接受 `ec thread list` 打印的展示形态 `<peer>/<id>`，
+ * 剥掉对端前缀后返回裸 id；其余值原样返回（裸话题 id、`main:<a>:<b>`、`all` 等由调用方
+ * 各自校验）。写了前缀时 `samePeer` 必须认可它与本次查询的对端一致，否则拒绝——
+ * 不能拿别的对端的话题引用去读当前对端的历史。
+ */
+export function normalizeThreadOptionValue(value, samePeer) {
+    const raw = value.trim();
+    const slash = raw.lastIndexOf('/');
+    if (slash < 0)
+        return { ok: true, threadId: raw };
+    const peer = raw.slice(0, slash).replace(/^@/, '');
+    const threadId = raw.slice(slash + 1);
+    if (!peer || !threadId)
+        return { ok: false, error: `无效的话题引用: ${raw}` };
+    if (threadId === 'main') {
+        return { ok: false, error: `<对端>/main 不是话题 id：主话题请用 main:<对端AID>:<本端AID>` };
+    }
+    if (samePeer && !samePeer(peer)) {
+        return { ok: false, error: `话题引用 ${raw} 的对端与查询对象不一致` };
+    }
+    return { ok: true, threadId, peer };
+}

package/dist/eck/kit-renderer.js

@@ -233,7 +233,7 @@ const PARAM_DESCRIPTIONS = {
     VENUES_DIR: '当前 agent 环境数据目录',
     selfAid: '当前 agent 的 AID',
     selfName: '当前 agent 的显示名',
-    lifecycle: '当前 agent 生命周期（created/bootstrapping/active）',
+    lifecycle: '当前 agent 生命周期（created/ownerpending/bootstrapping/active）',
     isBootstrapping: '当前 agent 是否处于 bootstrap 首次设定阶段',
     hasPersona: '是否有 persona 内容',
     hasWorkingMemory: '是否有 working memory',

package/dist/eck/message-renderer.js

@@ -133,7 +133,7 @@ function renderOneItem(item, sessionVars, sessionCache, contentSentinel) {
         injectTime: isOwnerHint
             ? formatLocalTime(item.injectTime ?? item.timestamp ?? Date.now(), sessionVars.timezone ? String(sessionVars.timezone) : undefined)
             : undefined,
-        // T4: 跨会话上下文（thread-inbox 注入）
+        // T4: 跨话题上下文（thread-inbox 注入）
         isThreadContext,
         threadContextOriginThreadId: item.threadContext?.originThreadId,
         threadContextOriginPeer: item.threadContext?.originPeer,
@@ -153,7 +153,9 @@ function renderOneItem(item, sessionVars, sessionCache, contentSentinel) {
             const tz = sessionVars.timezone ? String(sessionVars.timezone) : undefined;
             return `${formatLocalTime(g.firstTimestamp, tz)} - ${formatLocalTime(g.lastTimestamp, tz)}`;
         })(),
-        threadContextTriggerId: item.threadContext?.triggerId,
+        // 信封头的"复查"字段恒出现：复查 Trigger 没建成时显示"无"，不能整行省略——
+        // 省略时 agent 无从察觉复查缺失（2026-10-20 复查全部静默创建失败即如此）。
+        threadContextTriggerId: item.threadContext?.triggerId ?? '无',
         // T9: trigger 消息专属信封变量
         isTriggerMsg,
         triggerMsgId: isTriggerMsg ? item.triggerInfo?.triggerId : undefined,
@@ -161,6 +163,14 @@ function renderOneItem(item, sessionVars, sessionCache, contentSentinel) {
         triggerMsgFireTime: isTriggerMsg && item.triggerInfo?.fireTime !== undefined
             ? formatLocalTime(item.triggerInfo.fireTime, sessionVars.timezone ? String(sessionVars.timezone) : undefined)
             : undefined,
+        // 跨话题复查信封的"发送于"：原消息首次发送时间（labels.firstSentAt，ms 字符串），
+        // 与跨话题上下文信封的"发送于"同义、同格式。
+        triggerMsgFirstSentTime: (() => {
+            const ms = isTriggerMsg ? Number(item.triggerInfo?.labels?.firstSentAt) : NaN;
+            return Number.isFinite(ms) && ms > 0
+                ? formatLocalTime(ms, sessionVars.timezone ? String(sessionVars.timezone) : undefined)
+                : undefined;
+        })(),
         // T10: labels 路由 key（默认 'default'）+ 动态展开 triggerMsgLabel_<key>
         triggerMsgKind: isTriggerMsg ? (item.triggerInfo?.labels?.kind ?? 'default') : undefined,
         ...(isTriggerMsg && item.triggerInfo?.labels

package/dist/index.js

@@ -14,10 +14,12 @@ import { CodexSessionFileAdapter } from './core/session/adapters/codex-session-f
 import { GeminiSessionFileAdapter } from './core/session/adapters/gemini-session-file-adapter.js';
 import { EcagentSessionFileAdapter } from './core/session/adapters/ecagent-session-file-adapter.js';
 import { loadDefaults, loadAllAgents, migrateIdentitiesIfNeeded, loadDaemonConfig, initializeEckSnapshotsConfig } from './config-store.js';
+import { inspectClaudeSandboxDependencies, formatClaudeSandboxDependencies } from './core/permission/sandbox-runtime.js';
 import { migrateRelationSharedDirectories } from './core/relation/shared-data.js';
 import { DEFAULT_ECWEB_PORT, ecwebService } from './config/daemon-services.js';
-import { ConfigTarget, onConfigWrite, shouldFailFastForMissingOwners } from './config/config-manager.js';
+import { ConfigTarget, onConfigWrite } from './config/config-manager.js';
 import { expirePendingContactRequests } from './config/contact-request-service.js';
+import { synchronizeOwnershipContactsSync } from './config/contact-book-store.js';
 import { createSessionIdentityResolver } from './config/peer-role-resolver.js';
 import { initializeStartupConfig, prepareStartupConfig, recordStartupConfig } from './config/boot-log.js';
 import { CONFIG_SCHEMA_VERSION } from './types.js';
@@ -43,6 +45,7 @@ import { readFastaunVersion, readInstalledEvolcoreVersion, reportEvolcoreStartup
 import { recoverAllRoleMutationsSync } from './core/command/role-menu.js';
 import { HandoffRuntime } from './core/handoff/runtime.js';
 import { startDaemonControlAid } from './core/daemon-control.js';
+import { ownerResolver, getDaemonOwners } from './core/ownership/owner-resolver.js';
 import { cleanupStartupHandoffs, recoverStartupHandoffs, resumePendingSessions, createDaemonShutdown, daemonConversationTotalExecutionMs, daemonConversationWatchdogMs, daemonIdleTimeoutMs, } from './core/daemon-lifecycle.js';
 import { BootstrapService, createBootstrapCompletionHandler, createBootstrapOwnerBoundHandler } from './core/bootstrap-service.js';
 import { MessageCache } from './core/message/message-cache.js';
@@ -188,17 +191,19 @@ async function main() {
     loadKitManifest();
     // 加载配置（新结构：defaults.json + per-agent config.json）
     const defaults = loadDefaults() ?? { $schema_version: CONFIG_SCHEMA_VERSION };
-    let processLevelOwners = daemonCfg.owners ?? [];
-    const bindBootstrapMode = process.env.EVOLCORE_BIND_BOOTSTRAP === '1';
-    if (processLevelOwners.length === 0 && shouldFailFastForMissingOwners()) {
-        throw new Error('daemon.json.owners is required when EVOLCORE_REQUIRE_OWNERS=1');
+    const sandboxDependencies = inspectClaudeSandboxDependencies();
+    if (sandboxDependencies.status === 'missing') {
+        logger.warn(`[ClaudeSandbox] ${formatClaudeSandboxDependencies(sandboxDependencies)}`);
     }
-    // 进程级 menu 操作（/system /agent）鉴权：owners 来自 daemon.json 顶层。
-    // owners 为空时这些操作一律 FORBIDDEN，启动时提示如何配置。
-    if (processLevelOwners.length === 0) {
-        logger.warn('[startup] daemon.json.owners 未配置：进程级 menu 操作（/system /agent）将一律拒绝。' +
-            '如需远程管理，请在 daemon.json 配置 owners: [<你的 AID>]');
+    if (daemonCfg.aid) {
+        ownerResolver.setDaemonAid(daemonCfg.aid);
+        ownerResolver.setConfiguredOwners(daemonCfg.aid, [
+            daemonCfg.owner,
+            ...(daemonCfg.owners ?? []),
+        ].filter((owner) => typeof owner === 'string'));
     }
+    const processLevelOwners = getDaemonOwners;
+    const bindBootstrapMode = process.env.EVOLCORE_BIND_BOOTSTRAP === '1';
     const paths = resolvePaths();
     // ECWeb has one lifecycle owner: the daemon.  The CLI may have started an
     // instance just before spawning us; the supervisor adopts it when healthy,
@@ -333,16 +338,29 @@ async function main() {
             receiverAid: daemonCfg.aid,
             getAvailableBaseagents: detectAvailableBaseagents,
             getUptimeSeconds: () => Math.floor(process.uptime()),
-            onDaemonOwnersUpdated: (owners) => { processLevelOwners = owners; },
-            onAgentOwnerUpdated: createBootstrapOwnerBoundHandler({
-                getService: () => bootstrapService,
-                agentRegistry,
-                channelInstances,
-                eventBus,
-            }),
         })
         : null;
     bindService?.startCleanup();
+    const onProtocolOwnerBound = createBootstrapOwnerBoundHandler({
+        getService: () => bootstrapService, agentRegistry, channelInstances, eventBus,
+    });
+    let initializationServiceForOwnerRecovery;
+    const stopOwnerNotifications = ownerResolver.onChange((subjectAid, ownerAid) => {
+        permissionGateway.revalidatePendingApprovals(subjectAid);
+        if (agentRegistry.get(subjectAid)) {
+            try {
+                synchronizeOwnershipContactsSync(subjectAid);
+            }
+            catch (error) {
+                logger.warn(`[ownership] Contact role synchronization failed: self=${subjectAid} error=${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (!ownerAid)
+            return;
+        initializationServiceForOwnerRecovery?.resumeForOwner(subjectAid, ownerAid);
+        onProtocolOwnerBound(subjectAid, ownerAid);
+    });
+    onShutdown(() => { stopOwnerNotifications(); ownerResolver.stop(); });
     const agentDelegationRegistry = new AgentDelegationRegistry();
     // Replace any inherited marker from a parent/previous daemon before child
     // runners or in-process IPC clients are created.
@@ -424,7 +442,7 @@ async function main() {
     processor.setMessageQueue(messageQueue);
     const handoffQueueTtlMs = daemonIdleTimeoutMs(globalSettings);
     const taskExecutionTtlMs = daemonConversationTotalExecutionMs(globalSettings);
-    const handoffRuntime = new HandoffRuntime(sessionManager, messageQueue, createAunHandoffSender(sessionManager, channelInstances), undefined, { queueTtlMs: handoffQueueTtlMs });
+    const handoffRuntime = new HandoffRuntime(sessionManager, messageQueue, createAunHandoffSender(sessionManager, channelInstances, sessionId => responseEngine.getOutboundDebug(sessionId)), undefined, { queueTtlMs: handoffQueueTtlMs });
     responseEngine.setHandoffRuntime(handoffRuntime);
     cmdHandler.setHandoffRuntime(handoffRuntime);
     // Trigger runtime: daemon-level script + feedback scheduler.
@@ -471,12 +489,13 @@ async function main() {
         projectPath: primaryAgent?.projectPath || process.cwd(),
     };
     cmdHandler.setDaemonTriggerOwner(daemonTriggerOwner.aid, daemonChannel.channelName);
+    responseEngine.setDaemonTriggerOwner(daemonTriggerOwner.aid);
     const getTriggerChannel = createTriggerChannelResolver({ agentRegistry, channelInstances, daemonChannel, daemonTriggerOwner });
     const triggerAuthorizationDependencies = {
         agentDelegationRegistry,
         daemonTriggerOwner,
         getAgent: (agentAid) => agentRegistry.get(agentAid),
-        getDaemonOwners: () => loadDaemonConfig().owners ?? [],
+        getDaemonOwners,
         getTriggerChannel,
         sessionManager,
         triggerControlToken,
@@ -490,7 +509,7 @@ async function main() {
         });
     };
     const authorizeTriggerExecution = (definition) => (authorizeTriggerRun(definition, {
-        getDaemonOwners: () => loadDaemonConfig().owners ?? [],
+        getDaemonOwners,
     }));
     const authenticatedTriggerActor = (agentAid, actorSessionId, delegationToken, delegationCommandHash, controlToken, contextOnly = false) => authenticateTriggerActor(triggerAuthorizationDependencies, agentAid, actorSessionId, delegationToken, delegationCommandHash, controlToken, contextOnly);
     const sendConsolidationFeedback = createConsolidationFeedbackSender((agentAid, channelKey) => {
@@ -549,7 +568,7 @@ async function main() {
         return !!inst && inst.channel.getStatus?.().connected === true;
     };
     cmdHandler.setAgentStorageClientResolver(createAgentStorageClientResolver(channelInstances));
-    const msgBridge = new MessageBridge(defaultProjectPath, sessionManager, processor, messageQueue, cmdHandler, eventBus, primaryAgent?.config.debounce, () => processLevelOwners);
+    const msgBridge = new MessageBridge(defaultProjectPath, sessionManager, processor, messageQueue, cmdHandler, eventBus, primaryAgent?.config.debounce, processLevelOwners);
     msgBridge.setAgentRegistry(agentRegistry);
     msgBridge.setInteractionRouter(interactionRouter);
     msgBridge.setGroupInviteReviewService(groupInviteReviewService);
@@ -629,7 +648,7 @@ async function main() {
     // A failed bind (for example, a stale Windows named pipe) must abort startup
     // without creating a second AUN session that can kick the old daemon.
     let controlChannel;
-    const diagService = new DiagService(() => ({ controlAid: loadDaemonConfig().aid, owners: loadDaemonConfig().owners ?? [] }), async (to, text) => {
+    const diagService = new DiagService(() => ({ controlAid: loadDaemonConfig().aid, owners: getDaemonOwners() }), async (to, text) => {
         if (!controlChannel)
             throw new Error('Control AID channel is unavailable');
         const result = await controlChannel.sendDaemonMsg({ to, payload: { type: 'text', text }, encrypt: true });
@@ -647,7 +666,7 @@ async function main() {
         runtimeIsDist,
         runtimeBuildIdentity,
         diskDistDir,
-        getProcessOwners: () => processLevelOwners,
+        getProcessOwners: processLevelOwners,
         getAgentRuntimeState: () => agentRuntimeState,
         getAgentRuntimeError: () => agentRuntimeError,
         daemonAid: daemonCfg.aid,
@@ -722,7 +741,10 @@ async function main() {
         resync: coreResyncAgents,
         create: async (options) => {
             const { agentCreateNonInteractive } = await import('./cli/agent-create.js');
-            return await agentCreateNonInteractive(options, { hotLoadAgent: coreHotLoadAgent });
+            return await agentCreateNonInteractive(options, {
+                hotLoadAgent: coreHotLoadAgent,
+                bindOwnerAgent: (aid, ownerAid) => ownerResolver.bind(aid, ownerAid),
+            });
         },
         aunAids: () => channelInstances.flatMap(instance => {
             if (instance.channelType !== 'aun')
@@ -739,9 +761,10 @@ async function main() {
         hotLoad: coreHotLoadAgent,
         activate: completeAgentBootstrap,
     });
+    initializationServiceForOwnerRecovery = agentInitializationService;
     agentApplicationService.setInitializationService(agentInitializationService);
     cmdHandler.setAgentApplicationService(agentApplicationService);
-    ipcServer.setRemoteAccessOwnerProvider(() => processLevelOwners[0]);
+    ipcServer.setRemoteAccessOwnerProvider(() => processLevelOwners()[0]);
     cmdHandler.setDaemonMonitorProvider(() => ipcServer.getMonitorSnapshot().snapshot);
     ipcServer.setShutdownExecutor(async (reason) => {
         if (!shutdown) {
@@ -781,7 +804,7 @@ async function main() {
         },
         bindService,
         diagService,
-        getProcessOwners: () => loadDaemonConfig().owners ?? [],
+        getProcessOwners: getDaemonOwners,
         getControlAidState: () => controlChannel?.getAidState?.(),
         daemonAid: daemonCfg.aid,
         triggerControlToken,
@@ -836,7 +859,7 @@ async function main() {
         cmdHandler,
         bindService,
         diagService,
-        getProcessOwners: () => loadDaemonConfig().owners ?? [],
+        getProcessOwners: getDaemonOwners,
     });
     // 统一 channel:health 跨通道通知（仅 auth_error）
     registerChannelHealthNotifications({ eventBus, channelInstances, agentRegistry });

package/dist/ipc.js

@@ -23,6 +23,8 @@ import { remoteAccessService } from './core/auth/remote-access-store.js';
 import { setModelCatalogDaemonOwner } from './core/model/model-catalog.js';
 import { RUNTIME_ENVIRONMENT_NAMES, setRuntimeEnvironmentOverride } from './config/runtime-env.js';
 import { MAIN_CLI_BIN } from './product.js';
+import { ownerResolver } from './core/ownership/owner-resolver.js';
+import { parseOwnershipCommand, executeOwnershipCommand, ownershipFailure } from './aun/aid/ownership-operation.js';
 import { delegationDiagnosticMessage, withDelegationDiagnosticContext, } from './core/auth/delegation-diagnostics.js';
 const isWindows = process.platform === 'win32';
 const isNamedPipe = (p) => isWindows && p.toLowerCase().startsWith('\\\\.\\pipe\\');
@@ -83,7 +85,7 @@ const MEMORY_COMMAND_ENDPOINTS = new Set([
     'memory.create', 'memory.update', 'memory.archive', 'memory.demote', 'memory.consolidate',
 ]);
 const DELEGATED_ARGV_ENDPOINTS = new Set([
-    'agent.op', 'config.op', 'contact.op', 'aid.op', 'group.op', 'msg.op', 'fs.op',
+    'agent.op', 'config.op', 'contact.op', 'aid.op', 'aid.ownership', 'group.op', 'msg.op', 'fs.op',
     'ctl', 'diag', 'menu-client.request', 'task.resume', 'queue.op', 'storage.auth', 'storage.upload',
     'trigger.op', 'skill.refresh', 'thread.op', 'local-command-context', 'evolagent.bootstrapComplete', ...MEMORY_COMMAND_ENDPOINTS,
     'handoff-return', 'handoff-recover-return', 'handoff-status', 'handoff-list', 'handoff-trace',
@@ -114,6 +116,8 @@ function requiresLocalControlToken(cmd) {
         return true;
     if (type === 'debug-issue-token')
         return true;
+    if (type === 'aid.ownership')
+        return !sessionId || !delegated;
     if (type === 'skill.refresh' || type === 'thread.op')
         return !sessionId || !delegated;
     return ['evolagent.bootstrapComplete', 'diag', 'handoff-status', 'handoff-list', 'handoff-trace', 'task.resume'].includes(type)
@@ -198,6 +202,7 @@ export class IpcServer {
     systemSessionCommandGate;
     codexPreToolUseExecutor;
     aunMsgSender;
+    aunRequestGetExecutor;
     diagExecutor;
     menuClientExecutor;
     handoffReturnExecutor;
@@ -206,6 +211,7 @@ export class IpcServer {
     handoffListExecutor;
     handoffTraceExecutor;
     bindExecutor;
+    aidOwnershipExecutor;
     configOperationExecutor;
     contactOperationExecutor;
     aidOperationExecutor;
@@ -508,6 +514,9 @@ export class IpcServer {
     setAunMsgSender(sender) {
         this.aunMsgSender = sender;
     }
+    setAunRequestGetExecutor(executor) {
+        this.aunRequestGetExecutor = executor;
+    }
     hasAunMsgSender() {
         return this.aunMsgSender !== undefined;
     }
@@ -538,6 +547,9 @@ export class IpcServer {
     setBindExecutor(executor) {
         this.bindExecutor = executor;
     }
+    setAidOwnershipExecutor(executor) {
+        this.aidOwnershipExecutor = executor;
+    }
     /** Inject DingTalk contact binding-code executor. */
     setDingtalkContactBindExecutor(executor) {
         this.dingtalkContactBindExecutor = executor;
@@ -1088,7 +1100,13 @@ export class IpcServer {
                     return { ok: false, error: 'Invalid model catalog scope' };
                 }
                 try {
-                    const { getLocalCatalog } = await import('./core/model/model-catalog.js');
+                    const { getLocalCatalog, getLocalProviderCatalog } = await import('./core/model/model-catalog.js');
+                    if (cmd.providerId !== undefined || cmd.serviceType !== undefined) {
+                        if (typeof cmd.providerId !== 'string' || typeof cmd.serviceType !== 'string' || cmd.self !== undefined) {
+                            return { ok: false, error: 'Invalid provider catalog scope' };
+                        }
+                        return { ok: true, snapshot: await getLocalProviderCatalog(cmd.providerId, cmd.serviceType, cmd.refresh === true) };
+                    }
                     return { ok: true, snapshot: await getLocalCatalog(cmd.self, cmd.baseagent, cmd.refresh === true) };
                 }
                 catch {
@@ -1191,6 +1209,23 @@ export class IpcServer {
                     return { ok: false, error: 'bind executor not configured' };
                 return this.bindExecutor.cancel(cmd.taskId);
             }
+            case 'aid.ownership': {
+                if (!Array.isArray(cmd.argv) || cmd.argv.some((value) => typeof value !== 'string')) {
+                    return { ok: false, code: 'INVALID_ARGUMENT', error: 'Ownership argv is required' };
+                }
+                if (cmd.sessionId || cmd.delegationToken) {
+                    if (!this.aidOwnershipExecutor)
+                        return { ok: false, code: 'DELEGATION_REQUIRED', error: 'Managed ownership is unavailable' };
+                    return this.aidOwnershipExecutor(cmd.argv, cmd.sessionId, cmd.delegationToken, cmd.delegationCommandHash);
+                }
+                try {
+                    const command = parseOwnershipCommand(cmd.argv);
+                    return { ok: true, state: await executeOwnershipCommand(command, ownerResolver.getDaemonAid()) };
+                }
+                catch (error) {
+                    return ownershipFailure(error);
+                }
+            }
             case 'dingtalk.contact-bind.register': {
                 if (!this.dingtalkContactBindExecutor) {
                     return { ok: false, error: 'dingtalk contact bind executor not configured' };
@@ -1476,6 +1511,21 @@ export class IpcServer {
                 }
                 return this.debugIssueTokenExecutor({ sessionId: cmd.sessionId });
             }
+            case 'aun-msg-request-get': {
+                if (!this.aunRequestGetExecutor)
+                    return { ok: false, code: 'NOT_CONFIGURED', error: 'AUN request registry is not configured' };
+                if (typeof cmd.aid !== 'string' || !cmd.aid)
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing aid' };
+                if (typeof cmd.requestId !== 'string' || !cmd.requestId)
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing requestId' };
+                return this.aunRequestGetExecutor({
+                    aid: cmd.aid,
+                    requestId: cmd.requestId,
+                    sessionId: typeof cmd.sessionId === 'string' ? cmd.sessionId : undefined,
+                    delegationToken: typeof cmd.delegationToken === 'string' ? cmd.delegationToken : undefined,
+                    delegationCommandHash: typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined,
+                });
+            }
             case 'aun-msg-send': {
                 if (cmd.argv !== undefined) {
                     if (!this.aunMsgSender)
@@ -1529,7 +1579,7 @@ export class IpcServer {
                     }
                     : undefined;
                 try {
-                    const normalizedPayload = payload && Object.prototype.hasOwnProperty.call(payload, 'mentions')
+                    const normalizedPayload = cmd.rawPayload !== true && payload && Object.prototype.hasOwnProperty.call(payload, 'mentions')
                         ? { ...payload, mentions: normalizeAunMentionEntries(payload.mentions) }
                         : payload;
                     return await this.aunMsgSender({
@@ -1537,6 +1587,7 @@ export class IpcServer {
                         to: cmd.to,
                         scope: cmd.scope === 'group' ? 'group' : 'msg',
                         payload: normalizedPayload,
+                        rawPayload: cmd.rawPayload === true,
                         file,
                         mentions: Object.prototype.hasOwnProperty.call(cmd, 'mentions')
                             ? normalizeAunMentionEntries(cmd.mentions)
@@ -1546,6 +1597,8 @@ export class IpcServer {
                         handoffContext: cmd.handoffContext,
                         originSessionId: typeof cmd.originSessionId === 'string' ? cmd.originSessionId : undefined,
                         originMessageId: typeof cmd.originMessageId === 'string' ? cmd.originMessageId : undefined,
+                        returnPolicy: cmd.returnPolicy === 'required' ? 'required' : cmd.returnPolicy === 'none' ? 'none' : undefined,
+                        timeoutMs: typeof cmd.timeoutMs === 'number' && Number.isFinite(cmd.timeoutMs) ? cmd.timeoutMs : undefined,
                         delegationToken: typeof cmd.delegationToken === 'string' ? cmd.delegationToken : undefined,
                         delegationCommandHash: typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined,
                         log,
@@ -1765,7 +1818,7 @@ export class IpcServer {
                     if (disabled)
                         return disabled;
                     const ownerAid = taskCtx.selfAid
-                        ? this.agentRegistry?.get(taskCtx.selfAid)?.config?.owners?.[0]
+                        ? ownerResolver.primaryOwner(taskCtx.selfAid)
                         : undefined;
                     const { launchConsolidation } = await import('./core/memory/consolidation.js');
                     if (!this.consolidationLaunchExecutor) {
@@ -2412,7 +2465,7 @@ export class IpcServer {
         if (disabled)
             return { error: disabled };
         const ownerAid = taskCtx.selfAid
-            ? this.agentRegistry?.get(taskCtx.selfAid)?.config?.owners?.[0]
+            ? ownerResolver.primaryOwner(taskCtx.selfAid)
             : undefined;
         if (allowed === 'owner' && !ownerAid) {
             return { error: { ok: false, code: 'INVALID_REQUEST', error: '当前 agent 未配置 owner' } };
@@ -2481,7 +2534,7 @@ export class IpcServer {
         try {
             if (!this.consolidationLaunchExecutor)
                 return;
-            const ownerAid = this.agentRegistry?.get(selfAid)?.config?.owners?.[0];
+            const ownerAid = ownerResolver.primaryOwner(selfAid);
             await this.consolidationLaunchExecutor({
                 taskCtx,
                 mode: 'forget',

package/dist/paths.js

@@ -34,6 +34,7 @@ export function resolvePaths() {
         outboxDir: path.join(root, 'data', 'outbox'),
         dataDir: path.join(root, 'data'),
         claudeModelCache: path.join(root, 'data', 'claude-model-cache.json'),
+        providersConfig: path.join(root, 'providers.json'),
         logs: path.join(root, 'logs'),
         agentsDir,
         lineStats: path.join(root, 'logs', 'line-stats.log'),