agent-bridge-aun 1.0.48 → 1.0.50

package/README.md

@@ -23,7 +23,7 @@ mab aun repair-old-aids --json
 
 安装后在 ABWeb 的插件管理中启动 AUN 通道。收到的 AID 消息仅投递给用户在 AUN 身份页中明确关联的 Agent；未关联的 AID 消息会被忽略。旧配置中的 `agent_plugin` 字段不再作为默认路由。配置字段 `owner_aid` 是可选字符串，用作默认 Owner。AID 创建接口为 `POST /api/plugins/aun/aid`，请求内容为 `{"aid":"新AID.agentid.cn","owner_aid":"所有者AID.agentid.cn"}`。
 
-创建调用 SDK 0.5.31 的 `register(aid, { type: "agent", owner })`。注册、连接成功与 Owner 双边共识是不同状态；Owner 声明仍可能为 `single_sided/pending`，不能把“已创建”解释为归属已激活。创建后尝试把新 AID 加入 Owner 名录，默认 `allow_pa_use: true`；只有本地拥有 Owner 私钥且 Storage 可用时才能同步，失败通过 `directorySync` 单独返回。Gateway 信任根使用随插件提供并校验指纹的 AUN 根证书，不从 Gateway 下载未经验证的 CA 链。
+创建调用 SDK 0.5.31 的 `register(aid, { type: "agent", owner })`。注册、连接成功与 Owner 双边共识是不同状态；Owner 声明仍可能为 `single_sided/pending`，不能把“已创建”解释为归属已激活。创建后先读取新鲜签名归属；关联请求已送达但 Owner 尚未确认时，接口返回 `202`、`status: "等待 Owner 确认"`，页面和 CLI 仅给普通提醒，日志为 `info`，不重复注册或发送邀请，也不尝试用 Owner 公钥登录。仅共识成立后尝试把新 AID 加入 Owner 名录，默认 `allow_pa_use: true`；只有本地拥有 Owner 私钥且 Storage 可用时才能同步，失败通过 `directorySync` 单独返回。Gateway 信任根使用随插件提供并校验指纹的 AUN 根证书，不从 Gateway 下载未经验证的 CA 链。
 
 核心支持插件命令后，可运行 `mab aun status`、`mab aun list`、`mab aun agents`、`mab aun default-owner`、`mab aun default-owner set <owner-aid>`、`mab aun create <aid> [--owner <owner-aid>] [--agent <plugin-id>]`、`mab aun bind <aid> <plugin-id>` 和 `mab aun unbind <aid>`。关联或解绑只修改指定 AID，不会影响同一 Agent 下的其它 AID，也不会写入 Agent 全局 AID 配置。`default-owner` 不带参数显示当前配置，`default-owner set <owner-aid>` 校验格式并持久化新的默认值。`create` 明确传入 `--owner` 时优先使用该值；省略时回退到同一配置中的 `owner_aid`，两者都没有时返回错误，不会创建 AID。创建新身份时，实际使用的 Owner 会保存为下次默认值。ABWeb 从同一插件配置读取 `owner_aid` 并预填创建表单，因此 CLI 和 ABWeb 共用默认 Owner。Agent 从当前已就绪的插件动态发现。创建后连接或关联失败时，响应会标明 AID 已创建；先用 `mab aun list` 检查，不要重试创建。运行日志不记录原始参数或 Owner AID；默认 Owner 查询会在终端显示当前值。
 
@@ -71,4 +71,4 @@ AUN 独立包支持核心后台每五分钟检测更新；可信提供者在自
 显式关联已有 EvolCore Agent 的 AID 时，先执行 `ec agent disable <aid>`，再配置 `ecagent` 路由并重载。`ec` 不存在或命令失败时，只将所选 AID 的 JSON 配置更新为 `enabled=false`、`active_baseagent=ecagent` 和对应路由；其它 AID 保持原值。仍有 EvolCore 运行实例时，必须确认重载成功才完成关联，避免原 Claude 与桌面 Agent 同时回复。纯密钥库身份不调用 `ec`，解绑不自动启用原 Agent。
 ## Ability Owner 确认
 
-ABWeb 为 Provider AID 发起能力管理授权时，AUN 会向配置的 Owner AID 发送加密通知。Owner 在同一 AUN 会话中直接回复“确认”即可，不需要复制命令或令牌。确认按 Provider AID 保存，AUN 插件重载或升级后继续有效；只有 Provider 的 Owner 配置改变时才会撤销并要求重新确认。旧版 `/ability-owner <nonce>` 回复仍兼容。
+能力发布和远程调用审批由配置的 `ability_owners[providerAid]` 对应 Owner 在 AUN 加密私聊中管理。发送 `/ability help` 查看命令；`/ability list` 查看能力，`/ability publish <路径...>` 发布，`/ability revoke` 撤销，`/ability pending` 查看待审批清单。逐项处理使用通知中的 `/ability approve <操作键> <确认指纹>` 或 `/ability reject <操作键> <确认指纹>`。只有一项已送达申请时可直接回复“确认”或“拒绝”；多项需先送达固定清单，再用这两个词批量处理。新申请不会加入已展示清单，插件重载后需重新发送 `/ability pending`。Owner 首次发送有效管理命令时，AUN 验证其已配置 AID 并持久保存验证记录；远端消息不能设置或认领 Owner。能力的网页发布、Owner 验证和待审批区域已从 ABWeb 移除；已认证的本机管理 API 保留用于兼容旧管理客户端。

package/dist/src-ts/plugins/aun/ability-control.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAbilityControl = parseAbilityControl;
+exports.parseAbilityControlMessage = parseAbilityControlMessage;
+const aidPattern = /^[a-z0-9][a-z0-9_-]{2,63}\.[a-z0-9-]+(?:\.[a-z0-9-]+)+$/;
+const pathPattern = /^(?!protocol\/|definitions\/)[a-z0-9]+(?:[a-z0-9._-]*[a-z0-9])?(?:\/[a-z0-9]+(?:[a-z0-9._-]*[a-z0-9])?)+$/;
+const fingerprintPattern = /^[0-9a-f]{64}$/;
+const maxControlTextLength = 4096;
+function parseAbilityControl(text) {
+    if (text === "确认")
+        return { action: "confirm-view" };
+    if (text === "拒绝")
+        return { action: "reject-view" };
+    const trimmed = text.replace(/^ +| +$/g, "");
+    if (!/^\/ability(?:\s|$)/.test(trimmed))
+        return undefined;
+    if (text.length > maxControlTextLength)
+        throw new Error("Ability 管理命令过长，最多允许 4096 个字符");
+    if (!/^[a-z0-9./ _-]+$/.test(trimmed))
+        throw new Error("Ability 管理命令格式无效：请发送单行完整命令，仅使用空格分隔参数");
+    const [, action, ...args] = trimmed.split(/ +/);
+    if (["help", "list", "revoke", "pending"].includes(action) && args.length === 0)
+        return { action: action };
+    if (action === "publish") {
+        if (!args.length)
+            throw new Error("Ability 发布命令缺少路径参数");
+        if (args.some(path => path.length > 512 || !pathPattern.test(path)))
+            throw new Error("Ability 路径格式无效：必须符合插件 Ability path 规则且不能使用协议保留命名空间");
+        if (new Set(args).size !== args.length)
+            throw new Error("Ability 发布路径不能重复");
+        return { action, paths: args };
+    }
+    if ((action === "approve" || action === "reject") && args.length === 2) {
+        if (!args.every(value => fingerprintPattern.test(value)))
+            throw new Error("Ability 操作键与确认指纹格式无效：必须是完整的 64 位小写十六进制摘要");
+        return { action, key: args[0], confirmationFingerprint: args[1] };
+    }
+    throw new Error("Ability 管理命令或参数数量不正确，请发送 /ability help 查看用法");
+}
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function parseAbilityControlMessage(value, providerAid, ownerAid) {
+    const raw = record(value);
+    if (!raw)
+        return undefined;
+    const body = record(raw.payload);
+    const text = typeof raw.payload === "string" ? raw.payload : typeof body?.text === "string" ? body.text : "";
+    const command = parseAbilityControl(text);
+    if (!command)
+        return undefined;
+    const envelope = record(raw.envelope);
+    if (raw.envelope !== undefined && !envelope)
+        throw new Error("Ability 管理消息的认证信封格式无效");
+    const peerId = typeof raw.from === "string" ? raw.from : typeof envelope?.from === "string" ? envelope.from : "";
+    if (!aidPattern.test(peerId) || peerId === providerAid || !aidPattern.test(providerAid))
+        throw new Error("Ability 管理消息来源必须是该 Provider 配置的 Owner 身份");
+    for (const fields of [raw, body, envelope]) {
+        if (!fields)
+            continue;
+        if ([fields.from, fields.sender_aid].some(sender => sender !== undefined && sender !== peerId))
+            throw new Error("Ability 管理消息来源与认证信封身份不一致");
+        if (fields.to !== undefined && fields.to !== providerAid)
+            throw new Error("Ability 管理消息收件者与当前 Provider 不一致");
+    }
+    const privateMessage = [raw, body, envelope].every(fields => !fields || (fields.group_id === undefined && fields.group_aid === undefined
+        && (fields.chat_type === undefined || ["private", "direct", "p2p", "dm"].includes(String(fields.chat_type)))));
+    if (raw.encrypted !== true || !privateMessage)
+        throw new Error("Ability 管理命令仅接受 Owner 的加密私聊消息");
+    if ((raw.type !== undefined && !["text", "message"].includes(String(raw.type))) || (body?.type !== undefined && body.type !== "text")
+        || raw.attachments !== undefined || body?.attachments !== undefined)
+        throw new Error("Ability 管理命令必须是无附件的纯文本消息，通知和错误不能作为命令");
+    if (!ownerAid || !aidPattern.test(ownerAid))
+        throw Object.assign(new Error("尚未配置有效的 Ability Owner，请先在本机配置该 Provider 的 Owner AID"), { code: "ability_owner_unconfigured" });
+    if (peerId !== ownerAid)
+        throw new Error("Ability 管理消息来源必须是该 Provider 配置的 Owner 身份");
+    return { command, peerId,
+        ...(typeof raw.message_id === "string" ? { messageId: raw.message_id } : {}),
+        ...(typeof body?.thread_id === "string" ? { threadId: body.thread_id } : {}),
+    };
+}

package/dist/src-ts/plugins/aun/index.js

@@ -20,6 +20,7 @@ const ability_publication_1 = require("./ability-publication");
 const ability_operations_1 = require("./ability-operations");
 const ability_operation_store_1 = require("./ability-operation-store");
 const ability_owner_1 = require("./ability-owner");
+const ability_control_1 = require("./ability-control");
 const fs_1 = require("./fs");
 const fs_commands_1 = require("./fs-commands");
 const fs_transfer_1 = require("./fs-transfer");
@@ -30,7 +31,7 @@ const ownership_1 = require("./ownership");
 const sdk_loader_1 = require("./sdk-loader");
 const owned_profiles_1 = require("./owned-profiles");
 const manifest = {
-    id: "aun", version: "1.0.48", type: "channel", displayName: "AUN 通道",
+    id: "aun", version: "1.0.50", type: "channel", displayName: "AUN 通道",
     entry: "dist/src-ts/plugins/aun/index.js", apiVersion: "1", process: "in-process",
     capabilities: ["channel", "channel.identity.create", "channel.receive", "channel.send", "health", "cli"],
     configSchema: "config.schema.json",
@@ -108,6 +109,7 @@ class AunPlugin {
     abilityLedgers = {};
     abilityOwners = {};
     abilityOwnerVerifications = {};
+    abilityOwnerVerificationWrites = new Map();
     abilityOperations;
     peerMessages;
     abilityAuditUnavailable = false;
@@ -115,6 +117,7 @@ class AunPlugin {
     abilityPublications = new Map();
     revokingAbilityAids = new Set();
     abilityRevisions = new Map();
+    abilityApprovalViews = new Map();
     creating = false;
     repairingOwners = new Set();
     unregister = [];
@@ -329,6 +332,7 @@ class AunPlugin {
                     this.context?.logger.info("AUN 身份已创建", { aid });
                 }
                 const connectionError = !this.clients.has(aid) ? await this.connectAid(aid) : undefined;
+                let status = "已创建";
                 let directorySync;
                 try {
                     await this.syncOwnerDirectory(aid, owner);
@@ -336,10 +340,17 @@ class AunPlugin {
                     this.context?.logger.info("AUN 新 AID 已加入 Owner 名录", { aid });
                 }
                 catch (error) {
-                    directorySync = { status: "not_synced", error: safeError(error) };
-                    this.context?.logger.warn("AUN AID 已创建，但 Owner 名录未同步", { aid, error: directorySync.error });
+                    if (error instanceof fs_1.AunFsError && error.code === "OWNERSHIP_PENDING") {
+                        status = "等待 Owner 确认";
+                        directorySync = { status: "not_synced" };
+                        this.context?.logger.info("AUN AID 已创建并连接，关联请求已发送，等待 Owner 确认", { aid });
+                    }
+                    else {
+                        directorySync = { status: "not_synced", error: safeError(error) };
+                        this.context?.logger.warn("AUN AID 已创建，但 Owner 名录未同步", { aid, error: directorySync.error });
+                    }
                 }
-                return { aid, status: "已创建", connection: this.clients.has(aid) ? "ready" : "degraded", ...(connectionError ? { connectionError } : {}), directorySync };
+                return { aid, status, connection: this.clients.has(aid) ? "ready" : "degraded", ...(connectionError ? { connectionError } : {}), directorySync };
             }
             finally {
                 this.creating = false;
@@ -461,12 +472,25 @@ class AunPlugin {
     async syncOwnerDirectory(aid, ownerAid) {
         if (aid === ownerAid)
             throw new Error("新 AID 与 Owner AID 相同，未写入 Owner 名录");
+        const subClient = this.clients.get(aid)?.client;
+        if (this.store?.resolve && subClient?.checkOwnershipConsensus) {
+            const verified = await (0, ownership_1.readAunOwnership)(this.store, subClient, aid);
+            if (verified.declaredOwner !== ownerAid)
+                throw new fs_1.AunFsError("OWNERSHIP_CONFLICT", "指定 Owner 与已验签的现有 Owner 不同，未同步名录");
+            if (verified.ownership.status === "single_sided")
+                throw new fs_1.AunFsError("OWNERSHIP_PENDING", "关联请求已发送，等待 Owner 确认；确认前暂不加入通信名录，请勿重复创建 AID");
+            if (verified.ownership.status !== "consensus")
+                throw new fs_1.AunFsError("OWNERSHIP_UNAVAILABLE", `Owner 归属尚未核验完成（${verified.ownership.status}），未同步名录`);
+        }
         let client = this.ownerClients.get(ownerAid)?.client ?? this.clients.get(ownerAid)?.client;
         let temporary = false;
         if (!client) {
             const loaded = this.store?.load(ownerAid);
             if (!loaded?.ok || !loaded.data)
                 throw new Error("Owner AID 不在本地密钥库，AID 已创建但无法同步 Owner 名录");
+            // SDK load() 成功也可能只有公钥证书；list() 只返回持有有效私钥的身份。
+            if (!this.listStoreAids().includes(ownerAid))
+                throw new Error("本机没有 Owner 的有效私钥，AID 已创建但无法在本机同步 Owner 名录");
             await this.prepareTrustRoots(ownerAid);
             const trusted = this.store?.load(ownerAid);
             if (!trusted?.ok || !trusted.data)
@@ -516,18 +540,38 @@ class AunPlugin {
         await (0, promises_1.writeFile)((0, node_path_1.join)(this.context.dataDir, "config.json"), `${JSON.stringify(this.config, null, 2)}\n`, { mode: 0o600 });
     }
     async saveAbilityOwnerVerification(aid, ownerAid) {
-        const previous = this.abilityOwnerVerifications;
-        this.abilityOwnerVerifications = { ...previous, [aid]: ownerAid };
+        const pending = this.abilityOwnerVerificationWrites.get(aid);
+        if (pending)
+            return pending;
+        if (this.isAbilityOwnerVerified(aid, ownerAid))
+            return;
+        const operation = Promise.resolve().then(async () => {
+            if (this.abilityOwners[aid] !== ownerAid)
+                throw new Error("Provider 的 Owner 配置已改变");
+            const previous = this.abilityOwnerVerifications[aid];
+            this.abilityOwnerVerifications = { ...this.abilityOwnerVerifications, [aid]: ownerAid };
+            try {
+                await this.persist();
+            }
+            catch (error) {
+                if (previous === undefined)
+                    delete this.abilityOwnerVerifications[aid];
+                else
+                    this.abilityOwnerVerifications[aid] = previous;
+                throw error;
+            }
+        });
+        this.abilityOwnerVerificationWrites.set(aid, operation);
         try {
-            await this.persist();
+            await operation;
         }
-        catch (error) {
-            this.abilityOwnerVerifications = previous;
-            throw error;
+        finally {
+            if (this.abilityOwnerVerificationWrites.get(aid) === operation)
+                this.abilityOwnerVerificationWrites.delete(aid);
         }
     }
     isAbilityOwnerVerified(aid, ownerAid) {
-        return this.abilityOwners[aid] === ownerAid && this.abilityOwnerVerifications[aid] === ownerAid;
+        return !this.abilityOwnerVerificationWrites.has(aid) && this.abilityOwners[aid] === ownerAid && this.abilityOwnerVerifications[aid] === ownerAid;
     }
     async activate(context) {
         this.context = context;
@@ -570,6 +614,7 @@ class AunPlugin {
         this.sdk ??= await loadSdk();
         await (0, promises_1.mkdir)(this.path(), { recursive: true });
         this.ownerProof.clear();
+        this.abilityApprovalViews.clear();
         this.abilityAuditUnavailable = false;
         try {
             this.abilityOperations = await ability_operation_store_1.AbilityOperationStore.open((0, node_path_1.join)(context.dataDir, "ability-operations.json"));
@@ -806,6 +851,7 @@ class AunPlugin {
             clearInterval(this.ownedProfileTimer);
         this.ownedProfileTimer = undefined;
         this.ownerProof.clear();
+        this.abilityApprovalViews.clear();
         for (const { subscription, ownedSubscription } of this.clients.values()) {
             subscription?.unsubscribe();
             ownedSubscription?.unsubscribe();
@@ -983,42 +1029,52 @@ class AunPlugin {
             const paths = publish ? (Array.isArray(body.paths) && body.paths.every((path) => typeof path === "string") ? body.paths : undefined) : [];
             if (!paths)
                 return this.json(response, 400, { error: "发布路径必须是字符串数组" });
-            if (paths.length) {
-                const session = this.context?.managementSession?.(request);
-                const owner = this.abilityOwners[aid];
-                if (!session || !owner || !this.isAbilityOwnerVerified(aid, owner) || !this.context?.callPluginAbility || !this.abilityOperations || this.abilityAuditUnavailable)
-                    return this.json(response, 409, { error: "逐次 Owner 确认需可用操作账本、本机已认证管理会话，并先验证该 Provider 的 Owner AID" });
-                const operation = (this.abilityPublications.get(aid) ?? Promise.resolve()).catch(() => undefined).then(async () => {
-                    if (!this.isAbilityOwnerVerified(aid, owner) || this.abilityOwners[aid] !== owner || this.revokingAbilityAids.has(aid))
-                        throw new Error("Owner 验证已失效或身份正在撤销，请重新确认");
-                    const storage = this.clients.get(aid)?.client.storage;
-                    if (!storage)
-                        throw new Error("AUN 身份存储不可用");
-                    const pluginId = this.bindings[aid];
-                    const definitions = await this.abilityDefinitions(aid);
-                    const published = await (0, ability_publication_1.publishAbilityCatalog)({ storage, aid, pluginId, pluginVersion: this.context?.pluginVersion?.(pluginId) ?? "", definitions: definitions.map(definition => ({ ...definition })), selectedPaths: paths, ledger: this.abilityLedgers[aid] ?? {}, beforeIndexWrite: async (pending) => { this.abilityLedgers[aid] = pending; await this.persist(); } });
-                    this.abilityLedgers[aid] = published.ledger;
-                    this.abilitySelections[aid] = [...new Set(paths)];
-                    await this.persist();
-                });
-                this.abilityPublications.set(aid, operation);
-                try {
-                    await operation;
-                }
-                finally {
-                    if (this.abilityPublications.get(aid) === operation)
-                        this.abilityPublications.delete(aid);
-                }
-                return this.json(response, 200, { ok: true, aid, revoked: false });
-            }
-            await this.revokePublishedAbilities(aid);
-            return this.json(response, 200, { ok: true, aid, revoked: true });
+            const context = this.context;
+            const session = context.managementSession?.(request);
+            await this.setPublishedAbilities(aid, paths, () => this.context === context && Boolean(context.managementActor?.(request))
+                && (!paths.length || Boolean(session && context.managementSession?.(request)?.id === session.id)));
+            return this.json(response, 200, { ok: true, aid, revoked: !paths.length });
         }
         catch (error) {
             this.context?.logger.warn("AUN Ability 能力索引更新失败", { error: safeError(error) });
             return this.json(response, 409, { error: safeError(error) });
         }
     };
+    async setPublishedAbilities(aid, paths, authorized) {
+        const owner = this.abilityOwners[aid];
+        const assertAuthorized = () => {
+            if (paths.length && (!owner || !this.isAbilityOwnerVerified(aid, owner) || !this.context?.callPluginAbility || !this.abilityOperations || this.abilityAuditUnavailable || this.revokingAbilityAids.has(aid)))
+                throw new Error("逐次 Owner 确认需可用操作账本和已验证的 Owner AID，请重新确认");
+            if (!authorized())
+                throw new Error("能力发布的管理身份已失效");
+        };
+        assertAuthorized();
+        if (!paths.length) {
+            await this.revokePublishedAbilities(aid);
+            return;
+        }
+        const operation = (this.abilityPublications.get(aid) ?? Promise.resolve()).catch(() => undefined).then(async () => {
+            assertAuthorized();
+            const storage = this.clients.get(aid)?.client.storage;
+            if (!storage)
+                throw new Error("AUN 身份存储不可用");
+            const pluginId = this.bindings[aid];
+            const definitions = await this.abilityDefinitions(aid);
+            assertAuthorized();
+            const published = await (0, ability_publication_1.publishAbilityCatalog)({ storage, aid, pluginId, pluginVersion: this.context?.pluginVersion?.(pluginId) ?? "", definitions: definitions.map(definition => ({ ...definition })), selectedPaths: paths, ledger: this.abilityLedgers[aid] ?? {}, beforeIndexWrite: async (pending) => { assertAuthorized(); this.abilityLedgers[aid] = pending; await this.persist(); assertAuthorized(); } });
+            this.abilityLedgers[aid] = published.ledger;
+            this.abilitySelections[aid] = [...new Set(paths)];
+            await this.persist();
+        });
+        this.abilityPublications.set(aid, operation);
+        try {
+            await operation;
+        }
+        finally {
+            if (this.abilityPublications.get(aid) === operation)
+                this.abilityPublications.delete(aid);
+        }
+    }
     challengeAbilityOwner = async (request, response) => {
         const session = this.context?.managementSession?.(request);
         if (!this.context?.managementActor?.(request) || !session)
@@ -1035,6 +1091,9 @@ class AunPlugin {
                 this.revokingAbilityAids.add(aid);
                 this.abilityRevisions.set(aid, (this.abilityRevisions.get(aid) ?? 0) + 1);
                 this.ownerProof.clear(aid);
+                for (const key of this.abilityApprovalViews.keys())
+                    if (JSON.parse(key)[0] === aid)
+                        this.abilityApprovalViews.delete(key);
                 try {
                     await this.invalidateAbilityOperations(aid);
                     const previous = this.abilityOwners;
@@ -1078,84 +1137,233 @@ class AunPlugin {
         const session = this.context?.managementSession?.(request);
         if (!this.context?.managementActor?.(request) || !session)
             return this.json(response, 403, { error: "逐次 Owner 确认需本机已认证管理会话" });
-        const store = this.abilityOperations;
-        if (!store || this.abilityAuditUnavailable)
-            return this.json(response, 503, { error: "持久操作账本不可用" });
         try {
             const body = await this.readJsonBody(request);
             if (typeof body.key !== "string" || typeof body.confirmationFingerprint !== "string" || typeof body.approved !== "boolean")
                 return this.json(response, 400, { error: "必须明确提交操作键、完整确认指纹和批准或拒绝决定" });
-            const original = await store.get(body.key);
-            if (!original)
-                return this.json(response, 404, { error: "能力操作不存在" });
-            const ownerAid = this.abilityOwners[original.providerAid];
-            if (!ownerAid || !this.isAbilityOwnerVerified(original.providerAid, ownerAid))
-                return this.json(response, 403, { error: "需本机已认证管理会话，并完成该 Provider 的 Owner AID 验证" });
-            if (original.confirmationFingerprint !== body.confirmationFingerprint)
-                return this.json(response, 409, { error: "确认指纹与待确认请求不一致" });
-            const revision = this.abilityRevisions.get(original.providerAid) ?? 0;
-            if (body.approved && original.state === "pending_confirmation") {
-                const failure = await this.abilityInvocationFailure(original.providerAid, original.authenticatedCaller, original.path, original.definitionId, original.params);
-                const pluginId = this.bindings[original.providerAid];
-                if (failure || (this.abilityRevisions.get(original.providerAid) ?? 0) !== revision || this.revokingAbilityAids.has(original.providerAid) || original.executionTarget.pluginId !== pluginId || original.executionTarget.ownerAid !== ownerAid || original.executionTarget.pluginVersion !== (this.context?.pluginVersion?.(pluginId) ?? ""))
-                    return this.json(response, 409, { error: failure?.message ?? "能力执行目标或 Owner 配置已改变，请重新发起调用" });
-            }
-            if (!this.acceptingMessages || !this.isAbilityOwnerVerified(original.providerAid, ownerAid))
-                return this.json(response, 403, { error: "通道或 Owner 管理会话已失效" });
-            const confirmation = body.approved ? await store.approve(original.key, body.confirmationFingerprint) : await store.reject(original.key, body.confirmationFingerprint);
-            let entry = confirmation.entry;
-            if (confirmation.started) {
-                let result;
-                let state;
-                let handlerAuthorized = false;
-                try {
-                    const failure = await this.abilityInvocationFailure(entry.providerAid, entry.authenticatedCaller, entry.path, entry.definitionId, entry.params);
-                    const messageExpired = Date.now() >= entry.expiresAt;
-                    const confirmationExpired = Date.now() >= entry.confirmationExpiresAt;
-                    const expired = messageExpired || confirmationExpired;
-                    const invalidated = (this.abilityRevisions.get(entry.providerAid) ?? 0) !== revision || this.revokingAbilityAids.has(entry.providerAid);
-                    if (failure || expired || invalidated || !this.isAbilityOwnerVerified(entry.providerAid, ownerAid) || this.abilityOwners[entry.providerAid] !== entry.executionTarget.ownerAid || this.bindings[entry.providerAid] !== entry.executionTarget.pluginId || (this.context?.pluginVersion?.(String(entry.executionTarget.pluginId)) ?? "") !== entry.executionTarget.pluginVersion) {
-                        result = { ...(0, ability_operations_1.abilityFailureResult)({ call_id: entry.callId, operation_id: entry.operationId, ability_path: entry.path, definition_id: entry.definitionId }, expired ? (messageExpired ? "message_expired" : "confirmation_expired") : failure?.code ?? (invalidated ? "provider_invalidated" : "permission_denied"), messageExpired ? "调用已超过最晚启动时间" : confirmationExpired ? "Owner 确认申请已过期，不会执行" : failure?.message ?? "Owner 管理会话或执行目标已改变，本次能力没有执行"), execution_state: "not_executed" };
-                        state = "failed";
+            const context = this.context;
+            const result = await this.decideAbilityOperation(body.key, body.confirmationFingerprint, body.approved, () => this.context === context && Boolean(context.managementActor?.(request)) && context.managementSession?.(request)?.id === session.id);
+            this.json(response, 200, result);
+        }
+        catch (error) {
+            this.json(response, error instanceof AunCommandError ? error.statusCode : 409, { error: safeError(error) });
+        }
+    };
+    async decideAbilityOperation(key, fingerprint, approved, authorized, providerAid) {
+        const store = this.abilityOperations;
+        if (!store || this.abilityAuditUnavailable)
+            throw new AunCommandError("持久操作账本不可用", 503);
+        const original = await store.get(key);
+        if (!original || (providerAid !== undefined && original.providerAid !== providerAid))
+            throw new AunCommandError("能力操作不存在", 404);
+        const ownerAid = this.abilityOwners[original.providerAid];
+        if (!ownerAid || !this.isAbilityOwnerVerified(original.providerAid, ownerAid))
+            throw new AunCommandError("需完成该 Provider 的 Owner AID 验证", 403);
+        if (original.confirmationFingerprint !== fingerprint)
+            throw new AunCommandError("确认指纹与待确认请求不一致", 409);
+        const revision = this.abilityRevisions.get(original.providerAid) ?? 0;
+        if (approved && original.state === "pending_confirmation") {
+            const failure = await this.abilityInvocationFailure(original.providerAid, original.authenticatedCaller, original.path, original.definitionId, original.params);
+            const pluginId = this.bindings[original.providerAid];
+            if (failure || (this.abilityRevisions.get(original.providerAid) ?? 0) !== revision || this.revokingAbilityAids.has(original.providerAid) || original.executionTarget.pluginId !== pluginId || original.executionTarget.ownerAid !== ownerAid || original.executionTarget.pluginVersion !== (this.context?.pluginVersion?.(pluginId) ?? ""))
+                throw new AunCommandError(failure?.message ?? "能力执行目标或 Owner 配置已改变，请重新发起调用", 409);
+        }
+        if (!authorized() || !this.acceptingMessages || !this.isAbilityOwnerVerified(original.providerAid, ownerAid))
+            throw new AunCommandError("通道或 Owner 管理会话已失效", 403);
+        const confirmation = approved ? await store.approve(original.key, fingerprint) : await store.reject(original.key, fingerprint);
+        let entry = confirmation.entry;
+        if (confirmation.started) {
+            let result;
+            let state;
+            let handlerAuthorized = false;
+            try {
+                const failure = await this.abilityInvocationFailure(entry.providerAid, entry.authenticatedCaller, entry.path, entry.definitionId, entry.params);
+                const messageExpired = Date.now() >= entry.expiresAt;
+                const confirmationExpired = Date.now() >= entry.confirmationExpiresAt;
+                const expired = messageExpired || confirmationExpired;
+                const invalidated = (this.abilityRevisions.get(entry.providerAid) ?? 0) !== revision || this.revokingAbilityAids.has(entry.providerAid);
+                if (failure || expired || invalidated || !authorized() || !this.isAbilityOwnerVerified(entry.providerAid, ownerAid) || this.abilityOwners[entry.providerAid] !== entry.executionTarget.ownerAid || this.bindings[entry.providerAid] !== entry.executionTarget.pluginId || (this.context?.pluginVersion?.(String(entry.executionTarget.pluginId)) ?? "") !== entry.executionTarget.pluginVersion) {
+                    result = { ...(0, ability_operations_1.abilityFailureResult)({ call_id: entry.callId, operation_id: entry.operationId, ability_path: entry.path, definition_id: entry.definitionId }, expired ? (messageExpired ? "message_expired" : "confirmation_expired") : failure?.code ?? (invalidated ? "provider_invalidated" : "permission_denied"), messageExpired ? "调用已超过最晚启动时间" : confirmationExpired ? "Owner 确认申请已过期，不会执行" : failure?.message ?? "Owner 管理会话或执行目标已改变，本次能力没有执行"), execution_state: "not_executed" };
+                    state = "failed";
+                }
+                else {
+                    const context = this.context;
+                    const confirmed = entry;
+                    const beforeStart = () => {
+                        if (this.context !== context || this.abilityOperations !== store || this.abilityAuditUnavailable || !this.acceptingMessages || !authorized() || !this.isAbilityOwnerVerified(confirmed.providerAid, ownerAid) || this.abilityOwners[confirmed.providerAid] !== ownerAid)
+                            throw Object.assign(new Error("管理会话、Owner 证明或操作账本已失效，本次能力没有执行"), { code: "confirmation_unavailable" });
+                        const pluginId = String(confirmed.executionTarget.pluginId);
+                        const rules = String(this.config.allow_from ?? "").split(",").map(value => value.trim()).filter(Boolean);
+                        if ((this.abilityRevisions.get(confirmed.providerAid) ?? 0) !== revision || this.revokingAbilityAids.has(confirmed.providerAid) || !this.clients.has(confirmed.providerAid) || this.bindings[confirmed.providerAid] !== pluginId || this.abilityOwners[confirmed.providerAid] !== confirmed.executionTarget.ownerAid || (context.pluginVersion?.(pluginId) ?? "") !== confirmed.executionTarget.pluginVersion || context.pluginStatus(pluginId) !== "ready" || !this.abilitySelections[confirmed.providerAid]?.includes(confirmed.path) || this.abilityLedgers[confirmed.providerAid]?.[confirmed.path]?.definition_id !== confirmed.definitionId || (rules.length && !rules.includes("*") && !rules.includes(confirmed.authenticatedCaller)))
+                            throw Object.assign(new Error("Provider 发布、Owner policy 或执行目标已改变，本次能力没有执行"), { code: "provider_invalidated" });
+                        handlerAuthorized = true;
+                    };
+                    const value = await context.callPluginAbility(String(entry.executionTarget.pluginId), entry.path, entry.params, { providerAid: entry.providerAid, expiresAt: entry.expiresAt, beforeStart });
+                    result = { type: "ability", role: "result", ok: true, execution_state: "completed", result: value };
+                    state = "succeeded";
+                }
+            }
+            catch (error) {
+                this.context?.logger.warn("AUN Ability 执行失败，结果将持久保存", { aid: entry.providerAid, path: entry.path, error: safeError(error) });
+                const code = error.code;
+                const notExecuted = !handlerAuthorized && ["message_expired", "confirmation_expired", "provider_invalidated", "confirmation_unavailable"].includes(code ?? "");
+                result = { ...(0, ability_operations_1.abilityFailureResult)({ call_id: entry.callId, operation_id: entry.operationId, ability_path: entry.path, definition_id: entry.definitionId }, notExecuted ? code : "execution_failed", notExecuted ? (code === "message_expired" ? "调用已超过最晚启动时间" : code === "confirmation_expired" ? "Owner 确认申请已过期，不会执行" : "管理会话或 Provider 状态已改变，本次能力没有执行") : "能力执行失败，请检查 Provider 运行日志；不会自动重试"), execution_state: notExecuted ? "not_executed" : "failed" };
+                state = "failed";
+            }
+            entry = await store.finish(entry.key, state, result);
+        }
+        const delivered = await this.sendAbilityResponse(entry.providerAid, entry.authenticatedCaller, this.abilityOperationResponse(entry));
+        this.context?.logger.info("AUN Ability 逐次确认完成", { aid: entry.providerAid, callerAid: entry.authenticatedCaller, operationId: entry.operationId, state: entry.state, delivered });
+        return { ok: true, state: entry.state, result: entry.result, delivered };
+    }
+    abilityApprovalViewKey(aid, ownerAid, threadId) {
+        return JSON.stringify([aid, ownerAid, threadId ?? ""]);
+    }
+    async sendAbilityControlText(aid, ownerAid, text, threadId) {
+        const chunks = [];
+        const characters = Array.from(text);
+        for (let offset = 0; offset < characters.length; offset += 4000)
+            chunks.push(characters.slice(offset, offset + 4000).join(""));
+        for (const [index, part] of chunks.entries()) {
+            const message = chunks.length > 1 ? `Ability 管理消息（第 ${index + 1}/${chunks.length} 段，收全后再确认）\n${part}` : part;
+            const sent = await this.callAunWithRecovery(aid, { to: ownerAid, encrypt: true, payload: { type: "text", text: message, ...(threadId ? { thread_id: threadId } : {}) } });
+            if (typeof sent?.status !== "string" || !successfulSendStatuses.has(sent.status))
+                throw new Error(`AUN 管理回复投递状态未确认：${String(sent?.status ?? "未返回状态")}`);
+        }
+    }
+    abilityEntrySummary(entry) {
+        return [
+            `操作键：${entry.key}`,
+            `确认指纹：${entry.confirmationFingerprint}`,
+            `调用方：${entry.authenticatedCaller}`,
+            `Provider AID：${entry.providerAid}`,
+            `能力路径：${entry.path}`,
+            `definition_id：${entry.definitionId}`,
+            `原始参数：${JSON.stringify(entry.params)}`,
+            `影响：${entry.effects.join("、")}`,
+            `执行目标：${String(entry.executionTarget.pluginId)}（${String(entry.executionTarget.pluginVersion)}）`,
+            `operation_id：${entry.operationId}`,
+            `审批截止：${new Date(entry.confirmationExpiresAt).toLocaleString("zh-CN")}`,
+            `最晚启动：${new Date(entry.expiresAt).toLocaleString("zh-CN")}`,
+            `确认：/ability approve ${entry.key} ${entry.confirmationFingerprint}`,
+            `拒绝：/ability reject ${entry.key} ${entry.confirmationFingerprint}`,
+        ].join("\n");
+    }
+    async showAbilityPending(aid, ownerAid, threadId) {
+        const store = this.abilityOperations;
+        if (!store || this.abilityAuditUnavailable)
+            throw new AunCommandError("持久操作账本不可用", 503);
+        const entries = (await store.pending()).filter(entry => entry.providerAid === aid);
+        if (!entries.length) {
+            this.abilityApprovalViews.delete(this.abilityApprovalViewKey(aid, ownerAid, threadId));
+            await this.sendAbilityControlText(aid, ownerAid, "当前没有待确认的 Ability 调用。", threadId);
+            return;
+        }
+        const viewKey = this.abilityApprovalViewKey(aid, ownerAid, threadId);
+        const view = { explicit: true, entries: undefined };
+        this.abilityApprovalViews.set(viewKey, view);
+        const text = `待确认 Ability 调用清单（${entries.length} 项，仅包含本条消息展示的固定记录）\n\n${entries.map((entry, index) => `第 ${index + 1} 项\n${this.abilityEntrySummary(entry)}`).join("\n\n---\n\n")}\n\n回复“确认”或“拒绝”按本清单逐项处理；清单之后的新请求不会加入。`;
+        await this.sendAbilityControlText(aid, ownerAid, text, threadId);
+        if (this.abilityApprovalViews.get(viewKey) === view && this.abilityOperations === store && this.abilityOwners[aid] === ownerAid && this.acceptingMessages)
+            view.entries = entries.map(({ key, confirmationFingerprint }) => ({ key, confirmationFingerprint }));
+    }
+    async processAbilityControl(payload, aid) {
+        const raw = payload && typeof payload === "object" ? payload : undefined;
+        const body = raw?.payload && typeof raw.payload === "object" && !Array.isArray(raw.payload) ? raw.payload : undefined;
+        const text = typeof raw?.payload === "string" ? raw.payload : typeof body?.text === "string" ? body.text : "";
+        const isControlText = text === "确认" || text === "拒绝" || /^ *\/ability(?:\s|$)/.test(text);
+        if (!isControlText)
+            return false;
+        const ownerAid = this.abilityOwners[aid];
+        const envelope = raw?.envelope && typeof raw.envelope === "object" ? raw.envelope : undefined;
+        const sender = typeof raw?.from === "string" ? raw.from : typeof envelope?.from === "string" ? envelope.from : undefined;
+        if (ownerAid && sender !== ownerAid)
+            return text === "确认" || text === "拒绝" ? false : true;
+        if (!ownerAid && (text === "确认" || text === "拒绝"))
+            return false;
+        let authenticated = false;
+        const context = this.context;
+        const store = this.abilityOperations;
+        const revision = this.abilityRevisions.get(aid) ?? 0;
+        const authorized = () => this.context === context && this.abilityOperations === store && this.acceptingMessages && !this.revokingAbilityAids.has(aid) && this.clients.has(aid) && Boolean(this.bindings[aid]) && (this.abilityRevisions.get(aid) ?? 0) === revision && this.abilityOwners[aid] === ownerAid && this.isAbilityOwnerVerified(aid, ownerAid);
+        try {
+            const authPayload = typeof raw?.payload === "string" ? "/ability help" : { ...body, text: "/ability help" };
+            (0, ability_control_1.parseAbilityControlMessage)({ ...raw, payload: authPayload }, aid, ownerAid);
+            authenticated = true;
+            const message = (0, ability_control_1.parseAbilityControlMessage)(payload, aid, ownerAid);
+            if (!message)
+                return false;
+            if (message.messageId && !this.seen.add(`ability-control:${aid}:${message.messageId}`))
+                return true;
+            if (!this.isAbilityOwnerVerified(aid, ownerAid))
+                await this.saveAbilityOwnerVerification(aid, ownerAid);
+            const { command, peerId, threadId } = message;
+            if (command.action === "confirm-view" || command.action === "reject-view") {
+                const key = this.abilityApprovalViewKey(aid, ownerAid, threadId);
+                const view = this.abilityApprovalViews.get(key);
+                this.abilityApprovalViews.delete(key);
+                if (!view?.entries?.length) {
+                    await this.sendAbilityControlText(aid, peerId, "当前话题没有已展示的待确认清单。请先发送 /ability pending，核对清单后再回复确认或拒绝。", threadId);
+                    return true;
+                }
+                const approved = command.action === "confirm-view";
+                const results = [];
+                for (const entry of view.entries) {
+                    try {
+                        const result = await this.decideAbilityOperation(entry.key, entry.confirmationFingerprint, approved, authorized, aid);
+                        results.push(`${entry.key.slice(0, 12)}：${String(result.state)}`);
                     }
-                    else {
-                        const context = this.context;
-                        const confirmed = entry;
-                        const beforeStart = () => {
-                            const currentSession = context.managementSession?.(request);
-                            if (this.context !== context || this.abilityOperations !== store || this.abilityAuditUnavailable || !this.acceptingMessages || !context.managementActor?.(request) || !currentSession || currentSession.id !== session.id || !this.isAbilityOwnerVerified(confirmed.providerAid, ownerAid) || this.abilityOwners[confirmed.providerAid] !== ownerAid)
-                                throw Object.assign(new Error("管理会话、Owner 证明或操作账本已失效，本次能力没有执行"), { code: "confirmation_unavailable" });
-                            const pluginId = String(confirmed.executionTarget.pluginId);
-                            const rules = String(this.config.allow_from ?? "").split(",").map(value => value.trim()).filter(Boolean);
-                            if ((this.abilityRevisions.get(confirmed.providerAid) ?? 0) !== revision || this.revokingAbilityAids.has(confirmed.providerAid) || !this.clients.has(confirmed.providerAid) || this.bindings[confirmed.providerAid] !== pluginId || this.abilityOwners[confirmed.providerAid] !== confirmed.executionTarget.ownerAid || (context.pluginVersion?.(pluginId) ?? "") !== confirmed.executionTarget.pluginVersion || context.pluginStatus(pluginId) !== "ready" || !this.abilitySelections[confirmed.providerAid]?.includes(confirmed.path) || this.abilityLedgers[confirmed.providerAid]?.[confirmed.path]?.definition_id !== confirmed.definitionId || (rules.length && !rules.includes("*") && !rules.includes(confirmed.authenticatedCaller)))
-                                throw Object.assign(new Error("Provider 发布、Owner policy 或执行目标已改变，本次能力没有执行"), { code: "provider_invalidated" });
-                            handlerAuthorized = true;
-                        };
-                        const value = await context.callPluginAbility(String(entry.executionTarget.pluginId), entry.path, entry.params, { providerAid: entry.providerAid, expiresAt: entry.expiresAt, beforeStart });
-                        result = { type: "ability", role: "result", ok: true, execution_state: "completed", result: value };
-                        state = "succeeded";
+                    catch (error) {
+                        results.push(`${entry.key.slice(0, 12)}：未处理（${safeError(error)}）`);
                     }
                 }
-                catch (error) {
-                    this.context?.logger.warn("AUN Ability 执行失败，结果将持久保存", { aid: entry.providerAid, path: entry.path, error: safeError(error) });
-                    const code = error.code;
-                    const notExecuted = !handlerAuthorized && ["message_expired", "confirmation_expired", "provider_invalidated", "confirmation_unavailable"].includes(code ?? "");
-                    result = { ...(0, ability_operations_1.abilityFailureResult)({ call_id: entry.callId, operation_id: entry.operationId, ability_path: entry.path, definition_id: entry.definitionId }, notExecuted ? code : "execution_failed", notExecuted ? (code === "message_expired" ? "调用已超过最晚启动时间" : code === "confirmation_expired" ? "Owner 确认申请已过期，不会执行" : "管理会话或 Provider 状态已改变，本次能力没有执行") : "能力执行失败，请检查 Provider 运行日志；不会自动重试"), execution_state: notExecuted ? "not_executed" : "failed" };
-                    state = "failed";
-                }
-                entry = await store.finish(entry.key, state, result);
+                await this.sendAbilityControlText(aid, peerId, `${approved ? "确认" : "拒绝"}处理完成：\n${results.join("\n")}`, threadId);
+                return true;
+            }
+            if (command.action === "help") {
+                await this.sendAbilityControlText(aid, peerId, "AUN Ability 管理命令：\n/ability list：查看当前 Provider 的能力\n/ability publish <路径...>：按完整路径列表发布\n/ability revoke：撤销本 Provider 的能力索引\n/ability pending：展示固定待确认清单\n/ability approve <操作键> <确认指纹>：批准单项\n/ability reject <操作键> <确认指纹>：拒绝单项\n也可在清单投递成功后回复“确认”或“拒绝”。", threadId);
+            }
+            else if (command.action === "list") {
+                const definitions = await this.abilityDefinitions(aid);
+                const selected = new Set(this.abilitySelections[aid] ?? []);
+                const lines = definitions.map(item => `${selected.has(item.path) ? "已发布" : "未发布"} ${item.path} | ${item.name} | ${(0, ability_publication_1.abilityDefinitionId)({ ...item })}`);
+                await this.sendAbilityControlText(aid, peerId, lines.length ? lines.join("\n") : "当前关联 Agent 没有可发布的 Ability。", threadId);
+            }
+            else if (command.action === "publish") {
+                await this.setPublishedAbilities(aid, command.paths, authorized);
+                await this.sendAbilityControlText(aid, peerId, `已发布 ${command.paths.length} 项 Ability：\n${command.paths.join("\n")}`, threadId);
+            }
+            else if (command.action === "revoke") {
+                this.abilityApprovalViews.delete(this.abilityApprovalViewKey(aid, ownerAid, threadId));
+                await this.setPublishedAbilities(aid, [], authorized);
+                await this.sendAbilityControlText(aid, peerId, "已撤销本 Provider 的 Ability 索引，并使现有待确认操作失效。", threadId);
+            }
+            else if (command.action === "pending")
+                await this.showAbilityPending(aid, peerId, threadId);
+            else if (command.action === "approve" || command.action === "reject") {
+                const result = await this.decideAbilityOperation(command.key, command.confirmationFingerprint, command.action === "approve", authorized, aid);
+                await this.sendAbilityControlText(aid, peerId, `Ability 操作状态：${String(result.state)}；结果已${result.delivered ? "回传 Peer" : "保存，等待重投"}。`, threadId);
             }
-            const delivered = await this.sendAbilityResponse(entry.providerAid, entry.authenticatedCaller, this.abilityOperationResponse(entry));
-            this.context?.logger.info("AUN Ability 逐次确认完成，需本机已认证管理会话", { aid: entry.providerAid, callerAid: entry.authenticatedCaller, operationId: entry.operationId, state: entry.state, delivered });
-            this.json(response, 200, { ok: true, state: entry.state, result: entry.result, delivered });
         }
         catch (error) {
-            this.json(response, 409, { error: safeError(error) });
+            const replyAid = authenticated ? ownerAid : error.code === "ability_owner_unconfigured" ? sender : undefined;
+            if (replyAid) {
+                try {
+                    await this.sendAbilityControlText(aid, replyAid, `Ability 管理操作未完成：${safeError(error)}`, typeof body?.thread_id === "string" ? body.thread_id : undefined);
+                }
+                catch (replyError) {
+                    this.context?.logger.warn("AUN Ability 管理错误回复失败", { aid, ownerAid, error: safeError(replyError) });
+                }
+            }
         }
-    };
+        return true;
+    }
     async revokePublishedAbilities(aid) {
         this.revokingAbilityAids.add(aid);
         this.abilityRevisions.set(aid, (this.abilityRevisions.get(aid) ?? 0) + 1);
+        for (const key of this.abilityApprovalViews.keys())
+            if (JSON.parse(key)[0] === aid)
+                this.abilityApprovalViews.delete(key);
         const operation = (this.abilityPublications.get(aid) ?? Promise.resolve()).catch(() => undefined).then(async () => {
             await this.invalidateAbilityOperations(aid);
             this.abilitySelections[aid] = [];
@@ -1431,8 +1639,8 @@ class AunPlugin {
             let task;
             let operationError;
             if (verified.ownership.status !== "consensus") {
-                const local = this.store?.load(ownerAid);
-                const connectedOwner = this.clients.get(ownerAid)?.client;
+                const local = this.listStoreAids().includes(ownerAid) ? this.store?.load(ownerAid) : undefined;
+                const connectedOwner = this.ownerClients.get(ownerAid)?.client ?? this.clients.get(ownerAid)?.client;
                 let temporary;
                 try {
                     if (connectedOwner || local?.ok && local.data) {
@@ -1579,7 +1787,7 @@ class AunPlugin {
             await this.requireAgent(agent);
         }
         const created = await this.createIdentity(aid, owner);
-        const data = { created: true, aid, connection: created.connection ?? "ready", directorySync: created.directorySync };
+        const data = { created: true, aid, connection: created.connection ?? "ready", directorySync: created.directorySync, ...(created.status === "等待 Owner 确认" ? { status: created.status } : {}) };
         if (created.connection !== "ready")
             throw new AunCommandError("AID 已创建，但连接失败；请先执行 mab aun list 确认，不要重试创建", 502, { ...data, connectionError: created.connectionError });
         if (agent) {
@@ -1592,9 +1800,10 @@ class AunPlugin {
             }
         }
         return {
-            message: created.directorySync?.status === "not_synced"
-                ? `AID 已创建${agent ? `并关联到 ${agent}` : "并连接"}，但 Owner 名录未同步：${created.directorySync.error ?? "原因未知"}`
-                : agent ? `AID 已创建并关联到 ${agent}` : "AID 已创建并连接",
+            message: created.status === "等待 Owner 确认" ? `AID 已创建并连接${agent ? `并关联到 ${agent}` : ""}，关联请求已发送，等待 Owner 确认`
+                : created.directorySync?.status === "not_synced"
+                    ? `AID 已创建${agent ? `并关联到 ${agent}` : "并连接"}，但 Owner 名录未同步：${created.directorySync.error ?? "原因未知"}`
+                    : agent ? `AID 已创建并关联到 ${agent}` : "AID 已创建并连接",
             data: { ...data, ...(agent ? { agent } : {}) },
         };
     }
@@ -1752,22 +1961,31 @@ class AunPlugin {
         const body = raw?.payload && typeof raw.payload === "object" && !Array.isArray(raw.payload) ? raw.payload : undefined;
         const envelope = raw?.envelope && typeof raw.envelope === "object" ? raw.envelope : undefined;
         const sender = typeof raw?.from === "string" ? raw.from : typeof envelope?.from === "string" ? envelope.from : undefined;
-        if (body?.text === "确认" && this.ownerProof.hasPendingConfirmation(aid)) {
+        const inboundText = typeof raw?.payload === "string" ? raw.payload : typeof body?.text === "string" ? body.text : "";
+        const inboundThreadId = typeof body?.thread_id === "string" ? body.thread_id : undefined;
+        if (inboundText === "确认" && this.ownerProof.hasPendingConfirmation(aid)) {
             const ownerAid = this.abilityOwners[aid];
-            const authenticated = Boolean(ownerAid && sender === ownerAid && raw?.encrypted === true
-                && (raw.to === undefined || raw.to === aid) && (raw.sender_aid === undefined || raw.sender_aid === sender)
-                && (envelope?.from === undefined || envelope.from === sender) && (envelope?.to === undefined || envelope.to === aid));
-            if (!authenticated || !this.ownerProof.acceptConfirmation(aid, sender, body.text, true)) {
+            let authenticated = false;
+            try {
+                authenticated = Boolean((0, ability_control_1.parseAbilityControlMessage)(payload, aid, ownerAid));
+            }
+            catch { /* 无效信封不能验证 Owner 身份。 */ }
+            if (!authenticated || !this.ownerProof.acceptConfirmation(aid, sender, inboundText, true)) {
                 this.context?.logger.warn("AUN Owner 确认未通过验证", { traceId: inboundId, aid, sender: sender ?? "", stage: "Owner 确认校验", reason: authenticated ? "没有有效的待确认通知" : "需要配置 Owner AID 通过加密消息直接回复确认" });
                 return;
             }
+            if (typeof raw?.message_id === "string")
+                this.seen.add(`ability-control:${aid}:${raw.message_id}`);
+            for (const key of this.abilityApprovalViews.keys())
+                if (JSON.parse(key)[0] === aid)
+                    this.abilityApprovalViews.delete(key);
             try {
                 await this.saveAbilityOwnerVerification(aid, ownerAid);
             }
             catch (error) {
                 this.context?.logger.error("AUN Owner 验证状态保存失败", { traceId: inboundId, aid, ownerAid, stage: "保存 Owner 验证", error: safeError((0, agent_1.errorDetails)(error)) });
                 try {
-                    await this.sendText(aid, sender, "Owner 控制权确认失败：验证结果无法持久保存，请检查 AUN 插件配置写入权限。", typeof body.thread_id === "string" ? body.thread_id : undefined, true);
+                    await this.sendText(aid, sender, "Owner 控制权确认失败：验证结果无法持久保存，请检查 AUN 插件配置写入权限。", inboundThreadId, true);
                 }
                 catch (replyError) {
                     this.context?.logger.warn("AUN Owner 验证结果回复失败", { aid, peer: sender, verified: false, stage: "发送 Owner 验证回执", error: safeError((0, agent_1.errorDetails)(replyError)) });
@@ -1775,7 +1993,7 @@ class AunPlugin {
                 return;
             }
             try {
-                await this.sendText(aid, sender, `Owner 控制权验证成功：${aid} 的 Owner 已保存。此操作不会批准任何能力调用，请回到 ABWeb 继续操作。`, typeof body.thread_id === "string" ? body.thread_id : undefined, true);
+                await this.sendText(aid, sender, `Owner 控制权验证成功：${aid} 的 Owner 已保存。此操作不会批准任何能力调用，请发送 /ability help 查看管理命令。`, inboundThreadId, true);
             }
             catch (error) {
                 this.context?.logger.warn("AUN Owner 验证结果回复失败", { aid, peer: sender, verified: true, stage: "发送 Owner 验证回执", error: safeError((0, agent_1.errorDetails)(error)) });
@@ -1787,6 +2005,9 @@ class AunPlugin {
         if (typeof body?.text === "string" && /^\/ability-owner(?:\s|$)/.test(body.text)) {
             let verified = Boolean(ownerCommand && (envelope?.from === undefined || envelope.from === sender) && this.ownerProof.accept(aid, sender, ownerCommand[1], raw?.encrypted === true));
             if (verified) {
+                for (const key of this.abilityApprovalViews.keys())
+                    if (JSON.parse(key)[0] === aid)
+                        this.abilityApprovalViews.delete(key);
                 const ownerAid = this.abilityOwners[aid];
                 try {
                     if (ownerAid === sender)
@@ -1802,10 +2023,10 @@ class AunPlugin {
             this.context?.logger.info("AUN 宿主委托的 Owner 控制权验证已处理", { aid, verified });
             if (sender && raw?.encrypted === true && (envelope?.from === undefined || envelope.from === sender)) {
                 const text = verified
-                    ? `Owner 控制权验证成功：${aid} 的 Owner 已保存。此操作不会批准任何能力调用，请回到 ABWeb 继续操作。`
+                    ? `Owner 控制权验证成功：${aid} 的 Owner 已保存。此操作不会批准任何能力调用，请发送 /ability help 查看管理命令。`
                     : !ownerCommand
-                        ? "Owner 控制权验证失败：指令格式不正确。请在 ABWeb 重新发送确认通知，并直接回复“确认”。"
-                        : "Owner 控制权验证失败：验证指令已过期、已使用，或与本次 Owner 身份不匹配。请在 ABWeb 重新发起验证，并使用指定 Owner AID 回复。";
+                        ? "Owner 控制权验证失败：指令格式不正确。请使用已配置的 Owner AID 发送 /ability help。"
+                        : "Owner 控制权验证失败：验证指令已过期、已使用，或与本次 Owner 身份不匹配。请使用已配置的 Owner AID 发送 /ability help 重新验证。";
                 try {
                     await this.sendText(aid, sender, text, typeof body.thread_id === "string" ? body.thread_id : undefined, true);
                 }
@@ -1815,6 +2036,8 @@ class AunPlugin {
             }
             return;
         }
+        if (await this.processAbilityControl(payload, aid))
+            return;
         if ((0, ability_operations_1.isAbilityMessage)(payload)) {
             if (this.revokingAbilityAids.has(aid)) {
                 this.context?.logger.warn("AUN 身份正在撤销能力索引，能力调用已阻止", { aid, traceId: inboundId, stage: "撤销保护" });
@@ -2033,24 +2256,25 @@ class AunPlugin {
     }
     async notifyAbilityOwner(entry) {
         const ownerAid = String(entry.executionTarget.ownerAid ?? "");
-        const text = [
-            "有新的远程 Ability 调用申请",
-            `调用方：${entry.authenticatedCaller}`,
-            `Provider AID：${entry.providerAid}`,
-            `能力路径：${entry.path}`,
-            `operation_id：${entry.operationId}`,
-            `Owner 审批截止：${new Date(entry.confirmationExpiresAt).toLocaleString("zh-CN")}`,
-            `调用最晚启动时间：${new Date(entry.expiresAt).toLocaleString("zh-CN")}`,
-            "请在 ABWeb → AUN 通道 → 待确认能力调用中核对并批准一次或拒绝。只有在调用最晚启动时间前批准才会执行；12 小时审批期限不会延长协议调用 TTL。",
-        ].join("\n");
+        const viewKey = this.abilityApprovalViewKey(entry.providerAid, ownerAid);
+        const existingView = this.abilityApprovalViews.get(viewKey);
+        const view = existingView ?? {};
+        if (!existingView)
+            this.abilityApprovalViews.set(viewKey, view);
+        const pending = (await this.abilityOperations?.pending() ?? []).filter(item => item.providerAid === entry.providerAid);
+        if (pending.length !== 1 && !view.explicit)
+            view.entries = undefined;
+        const text = `有新的远程 Ability 调用申请\n${this.abilityEntrySummary(entry)}\n\n审批窗口最长 12 小时，不会延长调用最晚启动时间或协议 TTL。\n只有本话题中唯一、已完整投递的申请可直接回复“确认”或“拒绝”；多项、已处理或不确定时先发送 /ability pending 查看固定清单。`;
         try {
-            const sent = await this.callAunWithRecovery(entry.providerAid, { to: ownerAid, encrypt: true, payload: { type: "text", text } });
-            if (typeof sent?.status !== "string" || !successfulSendStatuses.has(sent.status))
-                throw new Error(`AUN 通知投递状态未确认：${sent?.status === undefined ? "未返回状态" : String(sent.status)}`);
-            this.context?.logger.info("AUN Ability Owner 申请通知已投递", { aid: entry.providerAid, ownerAid, callerAid: entry.authenticatedCaller, path: entry.path, operationId: entry.operationId, status: sent.status, stage: "Owner 申请通知" });
+            await this.sendAbilityControlText(entry.providerAid, ownerAid, text);
+            const current = (await this.abilityOperations?.pending() ?? []).filter(item => item.providerAid === entry.providerAid);
+            if (!existingView && this.abilityApprovalViews.get(viewKey) === view)
+                view.entries = current.length === 1 && current[0].key === entry.key && this.abilityOwners[entry.providerAid] === ownerAid && this.acceptingMessages
+                    ? [{ key: entry.key, confirmationFingerprint: entry.confirmationFingerprint }] : undefined;
+            this.context?.logger.info("AUN Ability Owner 申请通知已投递", { aid: entry.providerAid, ownerAid, callerAid: entry.authenticatedCaller, path: entry.path, operationId: entry.operationId, stage: "Owner 申请通知" });
         }
         catch (error) {
-            this.context?.logger.warn("AUN Ability Owner 申请通知发送失败，待确认请求仍保留在 ABWeb", { aid: entry.providerAid, ownerAid, callerAid: entry.authenticatedCaller, path: entry.path, operationId: entry.operationId, stage: "Owner 申请通知", error: safeError((0, agent_1.errorDetails)(error)) });
+            this.context?.logger.warn("AUN Ability Owner 申请通知发送失败，请用 /ability pending 读取保留的待确认请求", { aid: entry.providerAid, ownerAid, callerAid: entry.authenticatedCaller, path: entry.path, operationId: entry.operationId, stage: "Owner 申请通知", error: safeError((0, agent_1.errorDetails)(error)) });
         }
     }
     async abilityInvocationFailure(aid, callerAid, path, definitionId, params) {
@@ -2106,6 +2330,7 @@ class AunPlugin {
     }
     async processMessage(message, aid, agentPlugin, inboundId) {
         let deliveryFailed = false;
+        let failureText;
         const trace = { traceId: message.messageId || inboundId, aid, peer: message.peerId, threadId: message.threadId ?? "", messageId: message.messageId ?? "", agentPlugin };
         this.context?.logger.info("AUN 收到任务", { ...trace, stage: "接收消息", attachments: message.attachments?.length ?? 0 });
         const client = this.clients.get(aid)?.client;
@@ -2153,7 +2378,9 @@ class AunPlugin {
                 }
                 catch (error) {
                     deliveryFailed = true;
-                    throw new agent_1.AgentOperationError("AUN_TEXT_SEND_FAILED", "发送 AUN 文本消息（结果未确认，不自动重发）", error);
+                    const failure = new agent_1.AgentOperationError("AUN_TEXT_SEND_FAILED", "发送 AUN 文本消息（结果未确认，不自动重发）", error);
+                    failureText = `回复回传失败：${safeError((0, agent_1.errorDetails)(failure))}`;
+                    throw failure;
                 }
             },
             replyAttachments: async (items, text, signal) => {
@@ -2223,6 +2450,7 @@ class AunPlugin {
                     deliveryFailed = true;
                     const failure = sending ? new agent_1.AgentOperationError("AUN_ATTACHMENT_SEND_FAILED", "发送 AUN 附件消息（FS 上传已完成）", error) : error;
                     const progress = sending ? `（已确认发送 ${sent}/${groupsCount} 组，当前组结果未确认，请勿重复发送）` : "";
+                    failureText = `附件回传失败${progress}：${safeError((0, agent_1.errorDetails)(failure))}`;
                     const fallback = fallbackText && fallbackLinks.length ? `\n${withFailureDownloadLinks(fallbackText, fallbackLinks.map((url) => ({ url })))}` : "";
                     try {
                         await this.sendText(aid, message.peerId, `附件回传失败${progress}：${safeError((0, agent_1.errorDetails)(failure))}${fallback}`, message.threadId, true, "markdown");
@@ -2233,12 +2461,13 @@ class AunPlugin {
             },
         };
         const taskId = message.messageId || inboundId;
-        const notifyStatus = (status) => {
+        const notifyStatus = (status, text) => {
             if (!client?.notify)
                 return;
             const params = {
                 type: "task.status", status, task_id: taskId, session_id: taskId,
                 severity: status === "error" ? "error" : "info", initiator: message.peerId,
+                ...(text ? { text } : {}),
                 ...(message.threadId ? { thread_id: message.threadId } : {}),
                 ...(message.messageId ? { ref_message_id: message.messageId } : {}),
             };
@@ -2263,10 +2492,11 @@ class AunPlugin {
         catch (error) {
             failed = true;
             this.context?.logger.warn("AUN 消息处理失败", { ...trace, stage: deliveryFailed ? "回传回复" : "执行 Agent 任务", error: safeError((0, agent_1.errorDetails)(error)) });
+            const action = deliveryFailed ? "回复回传失败" : attachments.length > 0 ? "附件处理失败" : newSessionCommand.test(message.text.trim()) ? "新建会话失败" : "消息处理失败";
+            failureText ??= `${action}：${safeError((0, agent_1.errorDetails)(error))}`;
             if (!deliveryFailed) {
-                const action = attachments.length > 0 ? "附件处理失败" : newSessionCommand.test(message.text.trim()) ? "新建会话失败" : "消息处理失败";
                 try {
-                    await channelMessage.reply(`${action}：${safeError((0, agent_1.errorDetails)(error))}`);
+                    await channelMessage.reply(failureText);
                 }
                 catch (replyError) {
                     this.context?.logger.warn("AUN 错误回复失败", { ...trace, stage: "发送最终错误消息", error: safeError((0, agent_1.errorDetails)(replyError)) });
@@ -2275,7 +2505,7 @@ class AunPlugin {
         }
         finally {
             clearInterval(progressTimer);
-            notifyStatus(failed || deliveryFailed ? "error" : "completed");
+            notifyStatus(failed || deliveryFailed ? "error" : "completed", failureText);
         }
     }
     async sendText(aid, peerId, text, threadId, encryptedOnly = false, format) {

package/dist/src-ts/plugins/aun/public/app.js

@@ -4,12 +4,6 @@
   const list = find("#identities");
   const createForm = find("#create-form");
   const configForm = find("#config-form");
-  const abilityList = find("#abilities");
-  const pendingList = find("#ability-pending");
-  const abilityRows = new Map();
-  let pendingSnapshot;
-  let pendingRows = [];
-  let confirming = false;
   let agents = [];
   let loading = false;
 
@@ -59,130 +53,10 @@
           cell.append(select); row.append(cell); list.append(row);
       }
       if (!list.children.length) { const row = document.createElement("tr"); const cell = document.createElement("td"); cell.colSpan = 4; cell.textContent = "暂无已连接 AID"; row.append(cell); list.append(row); }
-      await loadAbilities(refreshForm);
-      await loadPending();
       show(`${entries.length} 个已连接 AID`);
     } catch (error) { show(String(error), true); }
     finally { loading = false; }
   }
-  function emptyRow(list, columns, message) {
-    const row = document.createElement("tr"); const cell = document.createElement("td"); cell.colSpan = columns; cell.textContent = message; row.append(cell); list.replaceChildren(row);
-  }
-  function ownerVerified(aid) {
-    const state = abilityRows.get(aid);
-    return Boolean(state?.item.ownerVerified && !state.challengeBusy && state.owner.value.trim() === state.item.ownerAid);
-  }
-  async function loadAbilities(refresh = true) {
-    const { abilities } = await request("/api/plugins/aun/abilities");
-    if (refresh) abilityRows.clear();
-    for (const [aid, item] of Object.entries(abilities || {})) {
-      const existing = abilityRows.get(aid);
-      if (existing) { existing.item = item; existing.sync(); continue; }
-      const row = document.createElement("tr");
-      for (const value of [aid, `${item.agent} / ${item.pluginVersion || "版本未知"}`]) { const cell = document.createElement("td"); cell.textContent = value; row.append(cell); }
-      const ownerCell = document.createElement("td"); ownerCell.className = "ability-owner";
-      const owner = document.createElement("input"); owner.type = "text"; owner.value = item.ownerAid || ""; owner.placeholder = "明确指定 Owner AID"; owner.setAttribute("aria-label", `${aid} 宿主委托 Owner AID`);
-      const challenge = document.createElement("button"); challenge.type = "button"; challenge.textContent = "发送 Owner 确认通知";
-      const proof = document.createElement("p"); proof.setAttribute("role", "status");
-      ownerCell.append(owner, challenge, proof); row.append(ownerCell);
-      const choices = document.createElement("td");
-      choices.className = "ability-options";
-      for (const definition of item.definitions || []) {
-        const label = document.createElement("label"); const input = document.createElement("input"); input.type = "checkbox"; input.value = definition.path; input.checked = (item.selected || []).includes(definition.path);
-        label.append(input, document.createTextNode(`${definition.name}（${definition.path}）`)); label.title = definition.summary; choices.append(label);
-      }
-      if (!choices.children.length) choices.textContent = "关联插件未就绪或没有声明能力";
-      if (item.reason) { const reason = document.createElement("p"); reason.textContent = item.reason; choices.append(reason); }
-      const actions = document.createElement("td");
-      const save = document.createElement("button"); save.type = "button"; save.textContent = "保存发布";
-      const revoke = document.createElement("button"); revoke.type = "button"; revoke.textContent = "撤销发布";
-      const state = { row, owner, item, busy: false, challengeBusy: false, challengeExpiresAt: 0, sync: () => {
-        const verified = ownerVerified(aid);
-        save.disabled = state.busy || !state.item.publishAvailable || !verified;
-        save.title = verified ? state.item.reason || "保存当前选择的能力" : "请先验证当前管理会话的宿主委托 Owner";
-        revoke.disabled = state.busy || !state.item.published;
-        challenge.disabled = state.challengeBusy || !owner.value.trim();
-        proof.textContent = verified ? "当前 Owner 已验证；每次调用仍须单独批准。" : state.challengeExpiresAt > Date.now() && owner.value.trim() === state.item.ownerAid ? `验证通知已通过 AUN 发送给指定 Owner，请直接回复“确认”；截止：${new Date(state.challengeExpiresAt).toLocaleString()}` : "当前 Owner 未验证，请发送确认通知。";
-      } };
-      abilityRows.set(aid, state);
-      owner.oninput = () => { state.sync(); for (const pending of pendingRows) pending.sync(); };
-      challenge.onclick = async () => {
-        if (state.challengeBusy || !owner.value.trim()) return;
-        const ownerAid = owner.value.trim();
-        state.challengeBusy = true;
-        state.item = { ...state.item, ownerVerified: false, publishAvailable: false };
-        state.sync(); for (const pending of pendingRows) pending.sync();
-        try {
-          const result = await request("/api/plugins/aun/abilities/owner-challenge", "POST", { aid, ownerAid });
-          state.item = { ...state.item, ownerAid, ownerVerified: Boolean(result.alreadyVerified), publishAvailable: Boolean(result.alreadyVerified) };
-          state.challengeExpiresAt = result.alreadyVerified ? 0 : result.expiresAt;
-          notify("Owner 确认通知结果", result.alreadyVerified ? `${ownerAid} 已完成验证，无需重复确认。` : `加密确认通知已通过 AUN 发送给 ${ownerAid}。请直接回复“确认”；仅验证 Owner 身份，不会执行能力。`);
-        } catch (error) { notify("Owner 验证发送失败", errorMessage(error), true); }
-        finally { state.challengeBusy = false; state.sync(); for (const pending of pendingRows) pending.sync(); }
-      };
-      const publish = async (paths) => {
-        if (state.busy) return;
-        if (paths.length && (!ownerVerified(aid) || !state.item.publishAvailable)) { notify("能力发布失败", "请先验证当前管理会话的宿主委托 Owner", true); return; }
-        state.busy = true; state.sync();
-        try { await request("/api/plugins/aun/abilities/publish", "POST", { aid, paths }); await loadAbilities(); notify("能力发布结果", paths.length ? `${aid} 已更新能力索引` : `${aid} 已撤销本通道发布的能力`); }
-        catch (error) { notify("能力发布失败", errorMessage(error), true); }
-        finally { state.busy = false; state.sync(); }
-      };
-      save.onclick = () => void publish([...choices.querySelectorAll("input:checked")].map(input => input.value));
-      revoke.onclick = () => void publish([]);
-      actions.append(save, revoke); row.append(choices, actions); state.sync();
-    }
-    for (const aid of abilityRows.keys()) if (!Object.hasOwn(abilities || {}, aid)) abilityRows.delete(aid);
-    const rows = [...abilityRows.values()].map(state => state.row);
-    if (refresh || rows.length !== abilityList.children.length || rows.some((row, index) => row !== abilityList.children[index])) abilityList.replaceChildren(...rows);
-    if (!abilityList.children.length) emptyRow(abilityList, 5, "暂无关联 Agent 的 AID");
-    for (const pending of pendingRows) pending.sync();
-  }
-  async function loadPending(force = false) {
-    const interacting = () => confirming || (!force && document.activeElement && pendingList.contains(document.activeElement));
-    if (interacting()) return;
-    const { operations = [] } = await request("/api/plugins/aun/abilities/pending");
-    if (interacting()) return;
-    const snapshot = JSON.stringify(operations);
-    if (snapshot === pendingSnapshot) { for (const pending of pendingRows) pending.sync(); return; }
-    pendingSnapshot = snapshot; pendingRows = []; pendingList.replaceChildren();
-    for (const entry of operations) {
-      const row = document.createElement("tr");
-      const cell = (text, pre = false) => { const td = document.createElement("td"); const content = pre ? document.createElement("pre") : td; content.textContent = text; if (pre) td.append(content); row.append(td); return td; };
-      cell(entry.providerAid); cell(entry.authenticatedCaller);
-      cell(`operation_id: ${entry.operationId}\nkey: ${entry.key}\nconfirmationFingerprint: ${entry.confirmationFingerprint}`, true);
-      cell(`path: ${entry.path}\ndefinition_id: ${entry.definitionId}`, true);
-      cell(JSON.stringify(entry.params, null, 2), true);
-      const details = cell(""); const contract = document.createElement("pre"); contract.textContent = `effects: ${JSON.stringify(entry.effects)}\n执行目标: ${JSON.stringify(entry.executionTarget, null, 2)}\nOwner 审批截止时间: ${new Date(entry.confirmationExpiresAt).toLocaleString()} (${entry.confirmationExpiresAt})\n调用最晚启动时间: ${new Date(entry.expiresAt).toLocaleString()} (${entry.expiresAt})\n状态: ${entry.state}`; details.append(contract);
-      const expiry = document.createElement("p"); details.append(expiry);
-      const actions = cell(""); const proof = document.createElement("p");
-      const approve = document.createElement("button"); approve.type = "button"; approve.textContent = "批准一次";
-      const reject = document.createElement("button"); reject.type = "button"; reject.textContent = "拒绝";
-      const pending = { sync: () => {
-        const verified = ownerVerified(entry.providerAid);
-        const confirmationExpired = !Number.isFinite(entry.confirmationExpiresAt) || entry.confirmationExpiresAt <= Date.now();
-        const messageExpired = !Number.isFinite(entry.expiresAt) || entry.expiresAt <= Date.now();
-        const unavailable = confirming || !verified || entry.state !== "pending_confirmation";
-        approve.disabled = unavailable || confirmationExpired || messageExpired; reject.disabled = unavailable || confirmationExpired;
-        expiry.textContent = confirmationExpired ? "Owner 审批申请已过期" : messageExpired ? "调用已超过最晚启动时间；不能再执行，但仍可拒绝" : "可在调用截止前批准一次；审批记录最长保留 12 小时";
-        proof.textContent = verified ? "当前会话的 Owner 已验证" : "此 Provider 的 Owner 未验证，请先验证 Owner";
-      } };
-      const confirm = async (approved) => {
-        pending.sync();
-        if (confirming || (approved ? approve.disabled : reject.disabled)) return;
-        confirming = true; for (const item of pendingRows) item.sync();
-        try {
-          const result = await request("/api/plugins/aun/abilities/confirm", "POST", { key: entry.key, confirmationFingerprint: entry.confirmationFingerprint, approved });
-          notify("能力确认结果", `状态：${result.state}\n${result.result ? JSON.stringify(result.result, null, 2) : ""}\n${result.delivered ? "结果已回投调用方" : "结果尚未送达调用方；不会自动重复执行"}`, result.state === "failed" || result.state === "unknown" || result.delivered === false);
-        } catch (error) { notify("能力确认失败", errorMessage(error), true); }
-        finally { confirming = false; for (const item of pendingRows) item.sync(); }
-        try { await loadPending(true); } catch (error) { show(`待确认列表刷新失败：${errorMessage(error)}`, true); }
-      };
-      approve.onclick = () => void confirm(true); reject.onclick = () => void confirm(false);
-      actions.append(proof, approve, reject); pendingRows.push(pending); pending.sync(); pendingList.append(row);
-    }
-    if (!pendingList.children.length) emptyRow(pendingList, 7, "暂无待确认的能力调用");
-  }
   async function bind(aid, pluginId) {
     try {
       await request(`/api/plugins/${encodeURIComponent(pluginId)}/aid`, "PATCH", { aid });
@@ -199,14 +73,16 @@
     show("正在创建 AID 并连接，请稍候……");
     void request("/api/plugins/aun/aid", "POST", { aid, ownerAid: owner }).then((result) => {
       const failed = result.connection === "degraded";
-      const directoryFailed = result.directorySync?.status === "not_synced";
+      const pending = result.status === "等待 Owner 确认";
+      const directoryFailed = !pending && result.directorySync?.status === "not_synced";
       const message = [
         failed ? `${aid} 已创建，但连接失败：${result.connectionError || "未提供连接失败原因，请查看运行日志"}\n身份已经保存在本地，请勿重复注册。`
-          : result.status === "等待 Owner 确认" ? `${aid} 等待 Owner 确认` : `${aid} 已创建并连接`,
-        directoryFailed ? `Owner 名录未同步：${result.directorySync.error || "原因未知"}`
+          : `${aid} 已创建并连接`,
+        pending ? "关联请求已发送，等待 Owner 确认；确认前暂不加入通信名录，请勿重复创建 AID。"
+          : directoryFailed ? `Owner 名录未同步：${result.directorySync.error || "原因未知"}`
           : result.directorySync?.status === "synced" ? "已加入 Owner 名录，个人助理可按默认权限使用该联系人。" : "Owner 名录同步状态未知，请查看运行日志。",
       ].join("\n");
-      notify(failed || directoryFailed ? "AID 创建完成，部分步骤失败" : "AID 创建结果", message, failed || directoryFailed);
+      notify(failed || directoryFailed ? "AID 创建完成，部分步骤失败" : pending ? "等待 Owner 确认" : "AID 创建结果", message, failed || directoryFailed);
       return load();
     }).catch((error) => notify("创建 AID 失败", errorMessage(error), true));
   };

package/dist/src-ts/plugins/aun/public/index.html

@@ -6,8 +6,6 @@
     <header><h1>AUN 身份</h1><button id="refresh" type="button">刷新</button></header>
     <p id="status" role="status"></p>
     <div class="table-scroll"><table><thead><tr><th>AID</th><th>来源</th><th>已关联 Agent</th><th>操作</th></tr></thead><tbody id="identities"></tbody></table></div>
-    <section><h2>Agent 能力发布</h2><p>默认不发布。请为每个 AID 明确选择公开能力，并验证宿主本地委托策略中的 Owner AID；此配置不代表 AUN 协议中的 ownership 关系。验证通知通过 AUN 加密发送给指定 Owner，Owner 直接回复“确认”即可，不需要复制命令或令牌。发布能力后，每次调用仍须单独确认。</p><div class="table-scroll"><table><thead><tr><th>Provider AID</th><th>关联 Agent / 版本</th><th>宿主委托 Owner</th><th>可发布能力</th><th>操作</th></tr></thead><tbody id="abilities"></tbody></table></div></section>
-    <section><h2>待确认能力调用</h2><p>有效请求会出现在此表格，Peer 同时收到 pending 回执，Owner 会收到加密通知。Owner 审批记录保留 12 小时；协议 TTL 仍是调用最晚启动时间，超过后不能再执行。核对认证调用方、原始参数、契约指纹、影响和执行目标；没有当前会话的 Owner 证明时，不能确认执行。</p><div class="table-scroll"><table class="ability-pending-table"><thead><tr><th>Provider AID</th><th>认证调用方</th><th>操作与确认指纹</th><th>能力路径 / 契约版本</th><th>原始参数</th><th>影响、执行目标与有效期</th><th>逐次确认</th></tr></thead><tbody id="ability-pending"></tbody></table></div></section>
     <form id="create-form"><h2>创建 AID</h2><div class="fields"><label>新 AID<input name="aid" required placeholder="例如：example.agentid.cn"></label><label>Owner AID<input name="ownerAid" placeholder="例如：owner.agentid.cn"><small class="hint">留空时使用已配置的默认 Owner；未配置时需填写。Owner 保存为本地归属配置；不代表 AUN 协议中的 Owner 关系已激活。</small></label></div><button type="submit">创建</button></form>
     <form id="config-form"><h2>通道配置</h2><div class="fields"><label>允许的来源<input name="allow_from" placeholder="留空接受所有 Peer，填写 AID 后限制"></label><label>AUN 存储路径<input name="aun_path"></label><label>加密种子<input name="encryption_seed" type="password" autocomplete="new-password" placeholder="留空则不修改"></label></div><button type="submit">保存配置</button></form>
   </main>

package/dist/src-ts/plugins/aun/public/style.css

@@ -17,14 +17,6 @@ table { width: 100%; min-width: 650px; border-collapse: collapse; font-size: 13p
 th, td { padding: 9px 8px; text-align: left; border-bottom: 1px solid #dce3df; }
 th { background: #edf1ef; color: #566761; }
 td select { max-width: 190px; }
-.ability-options label { display: flex; align-items: center; gap: 6px; }
-.ability-options input { min-height: auto; }
-.ability-owner { min-width: 220px; }
-.ability-owner input { width: 100%; margin-bottom: 6px; }
 td { vertical-align: top; }
-td button { margin: 0 6px 6px 0; }
-button:disabled { cursor: default; opacity: .55; }
-.ability-pending-table { min-width: 1050px; }
-.ability-pending-table pre { margin: 0; min-width: 160px; max-width: 340px; max-height: 260px; overflow: auto; white-space: pre-wrap; overflow-wrap: anywhere; font: inherit; }
 .error { color: #a83427; }
 @media (max-width: 620px) { .fields { grid-template-columns: 1fr; } }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-bridge-aun",
-  "version": "1.0.48",
+  "version": "1.0.50",
   "description": "mu-agent-bridge 的 AUN 通道插件。",
   "keywords": [
     "mu-agent-bridge-plugin",

package/plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "aun",
-  "version": "1.0.48",
+  "version": "1.0.50",
   "type": "channel",
   "displayName": "AUN 通道",
   "entry": "dist/src-ts/plugins/aun/index.js",