agent-bridge-aun 1.0.45-sdk0531.5 → 1.0.48

package/README.md

@@ -69,3 +69,6 @@ ABWeb 的 AUN 设置只展示已连接 AID，并按来源分组。成功注册
 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>` 回复仍兼容。

package/config.schema.json

@@ -127,6 +127,18 @@
         "type": "string",
         "pattern": "^[a-z0-9][a-z0-9_-]{2,63}\\.[a-z0-9-]+(?:\\.[a-z0-9-]+)+$"
       }
+    },
+    "ability_owner_verifications": {
+      "type": "object",
+      "default": {},
+      "description": "由 AUN 插件维护的 Owner 确认结果；仅当值与当前 ability_owners 相同时有效。",
+      "propertyNames": {
+        "pattern": "^[a-z0-9][a-z0-9_-]{2,63}\\.[a-z0-9-]+(?:\\.[a-z0-9-]+)+$"
+      },
+      "additionalProperties": {
+        "type": "string",
+        "pattern": "^[a-z0-9][a-z0-9_-]{2,63}\\.[a-z0-9-]+(?:\\.[a-z0-9-]+)+$"
+      }
     }
   },
   "additionalProperties": false

package/dist/src-ts/plugins/aun/ability-operation-store.js

@@ -5,6 +5,7 @@ exports.abilityOperationKey = abilityOperationKey;
 const node_crypto_1 = require("node:crypto");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
+const confirmationLifetimeMs = 12 * 60 * 60 * 1000;
 function failure(code, message) {
     return Object.assign(new Error(`${code}: ${message}`), { code });
 }
@@ -35,7 +36,10 @@ function operationFingerprint(input) {
     return digest({ providerAid: input.providerAid, authenticatedCaller: input.authenticatedCaller, operationId: input.operationId,
         path: input.path, definitionId: input.definitionId, params: input.params, effects: input.effects, executionTarget: input.executionTarget, async: input.async ?? false });
 }
-function confirmationFingerprint(input, fingerprint) {
+function confirmationFingerprint(input, fingerprint, confirmationExpiresAt) {
+    return digest({ key: abilityOperationKey(input), fingerprint, expiresAt: input.expiresAt, confirmationExpiresAt });
+}
+function legacyConfirmationFingerprint(input, fingerprint) {
     return digest({ key: abilityOperationKey(input), fingerprint, expiresAt: input.expiresAt });
 }
 function validateInput(input) {
@@ -62,11 +66,14 @@ function response(entry, code, message, executionState = "not_executed") {
 function validEntry(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
-    const entry = value;
+    const raw = value;
+    const legacy = raw.confirmationExpiresAt === undefined;
+    const entry = legacy ? { ...raw, confirmationExpiresAt: raw.expiresAt } : raw;
     try {
         validateInput(entry);
         if (entry.key !== abilityOperationKey(entry) || entry.fingerprint !== operationFingerprint(entry)
-            || entry.confirmationFingerprint !== confirmationFingerprint(entry, entry.fingerprint)
+            || !Number.isSafeInteger(entry.confirmationExpiresAt) || entry.confirmationExpiresAt <= 0
+            || entry.confirmationFingerprint !== (legacy ? legacyConfirmationFingerprint(entry, entry.fingerprint) : confirmationFingerprint(entry, entry.fingerprint, entry.confirmationExpiresAt))
             || !["pending_confirmation", "executing", "succeeded", "failed", "unknown"].includes(entry.state)
             || ![entry.createdAt, entry.updatedAt, entry.retainUntil].every(Number.isSafeInteger)
             || entry.createdAt < 0 || entry.updatedAt < entry.createdAt || entry.retainUntil < entry.createdAt + entry.dedupeRetentionSeconds * 1000)
@@ -113,7 +120,10 @@ class AbilityOperationStore {
         if (!snapshot || snapshot.version !== 1 || !Array.isArray(snapshot.entries) || !snapshot.entries.every(validEntry))
             throw failure("operation_store_corrupt", "操作账本格式无效，已停止新的执行");
         let migrated = false;
-        for (const entry of snapshot.entries) {
+        for (const saved of snapshot.entries) {
+            const legacy = saved.confirmationExpiresAt === undefined;
+            const entry = legacy ? { ...saved, confirmationExpiresAt: saved.expiresAt,
+                confirmationFingerprint: confirmationFingerprint(saved, saved.fingerprint, saved.expiresAt) } : saved;
             if (store.entries.has(entry.key))
                 throw failure("operation_store_corrupt", "操作账本含重复幂等键");
             const legacyExpired = entry.result?.error?.code === "expired";
@@ -125,6 +135,7 @@ class AbilityOperationStore {
             }
             else
                 store.entries.set(entry.key, entry);
+            migrated ||= legacy;
         }
         if (migrated)
             await store.persist(new Map(store.entries));
@@ -161,11 +172,11 @@ class AbilityOperationStore {
         const next = new Map(entries);
         let changed = false;
         for (const entry of entries.values()) {
-            if (entry.state !== "pending_confirmation" || now < entry.expiresAt)
+            if (entry.state !== "pending_confirmation" || now < entry.confirmationExpiresAt)
                 continue;
             next.set(entry.key, { ...entry, state: "failed", updatedAt: Math.max(entry.updatedAt, now),
                 retainUntil: Math.max(entry.retainUntil, now + entry.dedupeRetentionSeconds * 1000),
-                result: response(entry, "message_expired", "调用消息已过期，不会执行") });
+                result: response(entry, "confirmation_expired", "Owner 确认申请已过期，不会执行") });
             changed = true;
         }
         return { entries: next, changed };
@@ -188,9 +199,10 @@ class AbilityOperationStore {
                 return { created: false, entry: structuredClone(existing) };
             }
             const retainUntil = now + copied.dedupeRetentionSeconds * 1000;
-            if (!Number.isSafeInteger(retainUntil))
+            const confirmationExpiresAt = now + confirmationLifetimeMs;
+            if (!Number.isSafeInteger(retainUntil) || !Number.isSafeInteger(confirmationExpiresAt))
                 throw failure("params_invalid", "操作保留期无效");
-            const entry = { ...copied, key, fingerprint, confirmationFingerprint: confirmationFingerprint(copied, fingerprint),
+            const entry = { ...copied, key, fingerprint, confirmationExpiresAt, confirmationFingerprint: confirmationFingerprint(copied, fingerprint, confirmationExpiresAt),
                 state: "pending_confirmation", createdAt: now, updatedAt: now, retainUntil };
             next.set(key, entry);
             await this.persist(next);
@@ -216,11 +228,12 @@ class AbilityOperationStore {
             if (existing.state !== "pending_confirmation")
                 return { started: false, entry: structuredClone(existing) };
             const now = this.now();
+            const confirmationExpired = now >= existing.confirmationExpiresAt;
             const messageExpired = now >= existing.expiresAt;
-            const started = approve && !messageExpired;
+            const started = approve && !confirmationExpired && !messageExpired;
             const entry = { ...existing, state: started ? "executing" : "failed", updatedAt: Math.max(existing.updatedAt, now),
                 retainUntil: Math.max(existing.retainUntil, now + existing.dedupeRetentionSeconds * 1000),
-                ...(!started ? { result: messageExpired ? response(existing, "message_expired", "调用消息已过期，不会执行") : response(existing, "user_denied", "Owner 已拒绝本次调用") } : {}) };
+                ...(!started ? { result: confirmationExpired ? response(existing, "confirmation_expired", "Owner 确认申请已过期，不会执行") : approve && messageExpired ? response(existing, "message_expired", "调用已超过最晚启动时间") : response(existing, "user_denied", "Owner 已拒绝本次调用") } : {}) };
             const next = new Map(this.entries);
             next.set(key, entry);
             await this.persist(next);

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OwnerProof = void 0;
 const node_crypto_1 = require("node:crypto");
 const lifetime = 10 * 60_000;
+const confirmationLifetime = 12 * 60 * 60_000;
 const limit = 1024;
 const aidPattern = /^[a-z0-9][a-z0-9_-]{2,63}\.[a-z0-9-]+(?:\.[a-z0-9-]+)+$/;
 function key(session, providerAid, ownerAid) {
@@ -32,7 +33,7 @@ class OwnerProof {
         if (!this.entries.has(recordKey) && this.entries.size >= limit)
             throw new Error("Owner 证明记录已达上限，请稍后重试");
         const nonce = (0, node_crypto_1.randomBytes)(32).toString("hex");
-        const expiresAt = Math.min(session.expiresAt, now + lifetime);
+        const expiresAt = Math.min(session.expiresAt, now + confirmationLifetime);
         this.entries.set(recordKey, { providerAid, ownerAid, sessionExpiresAt: session.expiresAt, expiresAt, nonceHash: (0, node_crypto_1.createHash)("sha256").update(nonce).digest("hex") });
         return { nonce, expiresAt };
     }
@@ -51,6 +52,27 @@ class OwnerProof {
         }
         return false;
     }
+    acceptConfirmation(providerAid, authenticatedSenderAid, text, encrypted) {
+        const now = this.now();
+        this.prune(now);
+        if (encrypted !== true || !authenticatedSenderAid || text !== "确认")
+            return false;
+        for (const entry of this.entries.values()) {
+            if (entry.providerAid !== providerAid || entry.ownerAid !== authenticatedSenderAid || entry.nonceHash === undefined)
+                continue;
+            this.clear(providerAid);
+            return true;
+        }
+        return false;
+    }
+    hasPendingConfirmation(providerAid) {
+        const now = this.now();
+        this.prune(now);
+        for (const entry of this.entries.values())
+            if (entry.providerAid === providerAid && entry.nonceHash !== undefined)
+                return true;
+        return false;
+    }
     verified(session, providerAid, ownerAid) {
         const now = this.now();
         this.prune(now);

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

@@ -68,15 +68,14 @@ async function configureAidForPlugin(pluginId, aid, port, run = runEc, home = pr
         throw new Error("插件 ID 格式无效");
     if (!Number.isInteger(port) || port < 1 || port > 65535)
         throw new Error("后台端口无效");
-    const path = pluginId === "dsh" ? "/dsh/v1" : `/api/agents/${pluginId}/v1`;
-    const ecagent = { baseUrl: `http://127.0.0.1:${port}${path}`, apiKey: "mab-local", model: pluginId };
+    const baseagent = { provider: "provider-1", model: pluginId };
     try {
         // MAB 直接接收 AUN 消息，先停用该 AID 的 EvolCore Agent，避免双重回复。
         const disabled = await run(["agent", "disable", aid, "--format", "json"], home);
         if (!disabled?.ok)
             throw new Error(`停用原 Agent 失败：${disabled?.code ?? ""} ${disabled?.error ?? "未知错误"}`);
         for (const [key, value] of [
-            ...Object.entries(ecagent).map(([key, value]) => [`baseagents.ecagent.${key}`, value]),
+            ...Object.entries(baseagent).map(([key, value]) => [`baseagents.ecagent.${key}`, value]),
             ["active_baseagent", "ecagent"],
         ]) {
             const result = await run(["agent", "set", aid, key, value, "--format", "json"], home);
@@ -95,7 +94,10 @@ async function configureAidForPlugin(pluginId, aid, port, run = runEc, home = pr
             throw new Error(`AID ${aid} 原配置格式无效，未覆盖文件`);
         config.enabled = false;
         config.active_baseagent = "ecagent";
-        config.baseagents = { ...config.baseagents, ecagent: { ...config.baseagents?.ecagent, ...ecagent } };
+        const ecagent = config.baseagents?.ecagent ?? {};
+        delete ecagent.baseUrl;
+        delete ecagent.apiKey;
+        config.baseagents = { ...config.baseagents, ecagent: { ...ecagent, ...baseagent } };
         const temporary = `${file}.mab-${(0, node_crypto_1.randomUUID)()}.tmp`;
         try {
             await (0, promises_1.writeFile)(temporary, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });

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

@@ -30,7 +30,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.45-sdk0531.5", type: "channel", displayName: "AUN 通道",
+    id: "aun", version: "1.0.48", 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",
@@ -107,6 +107,7 @@ class AunPlugin {
     abilitySelections = {};
     abilityLedgers = {};
     abilityOwners = {};
+    abilityOwnerVerifications = {};
     abilityOperations;
     peerMessages;
     abilityAuditUnavailable = false;
@@ -511,8 +512,23 @@ class AunPlugin {
         this.config.ability_selections = this.abilitySelections;
         this.config.ability_ledgers = this.abilityLedgers;
         this.config.ability_owners = this.abilityOwners;
+        this.config.ability_owner_verifications = this.abilityOwnerVerifications;
         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 };
+        try {
+            await this.persist();
+        }
+        catch (error) {
+            this.abilityOwnerVerifications = previous;
+            throw error;
+        }
+    }
+    isAbilityOwnerVerified(aid, ownerAid) {
+        return this.abilityOwners[aid] === ownerAid && this.abilityOwnerVerifications[aid] === ownerAid;
+    }
     async activate(context) {
         this.context = context;
         this.config = { ...context.config };
@@ -610,12 +626,21 @@ class AunPlugin {
             || Object.entries(owners).some(([provider, owner]) => !aidPattern.test(provider) || typeof owner !== "string" || !aidPattern.test(owner))))
             throw new Error("ability_owners 必须按 Provider AID 配置有效的 Owner AID");
         this.abilityOwners = { ...owners };
+        const verifications = this.config.ability_owner_verifications;
+        if (verifications !== undefined && (!verifications || typeof verifications !== "object" || Array.isArray(verifications)
+            || Object.entries(verifications).some(([provider, owner]) => !aidPattern.test(provider) || typeof owner !== "string" || !aidPattern.test(owner))))
+            throw new Error("ability_owner_verifications 必须按 Provider AID 配置有效的 Owner AID");
+        const persistedVerifications = { ...verifications };
+        this.abilityOwnerVerifications = Object.fromEntries(Object.entries(persistedVerifications).filter(([provider, owner]) => this.abilityOwners[provider] === owner));
+        const staleOwnerVerification = Object.keys(this.abilityOwnerVerifications).length !== Object.keys(persistedVerifications).length;
         for (const aid of Array.isArray(this.config.identities) ? this.config.identities : []) {
             if (typeof aid === "string" && aidPattern.test(aid))
                 this.identities.add(aid);
         }
         if (this.aid)
             this.identities.add(this.aid);
+        if (staleOwnerVerification)
+            await this.persist();
         this.acceptingMessages = true;
         // 只订阅明确关联 Agent 的身份，避免接管 EvolCore 或其它 AID 的消息。
         for (const aid of Object.keys(this.bindings)) {
@@ -735,7 +760,11 @@ class AunPlugin {
         const connection = this.clients.get(aid);
         if (!connection || connection.subscription || !this.bindings[aid])
             return;
-        connection.subscription = connection.client.on("message.received", (payload) => this.onMessage(payload, aid));
+        connection.subscription = connection.client.on("message.received", (payload) => this.enqueueMessage(payload, aid));
+    }
+    enqueueMessage(payload, aid) {
+        // SDK 串行等待事件回调；任务由现有入站账本排空，不能占住 SDK 的消息分发队列。
+        void this.onMessage(payload, aid).catch(error => this.context?.logger.warn("AUN 入站消息处理失败", { aid, stage: "处理已接收消息", error: safeError((0, agent_1.errorDetails)(error)) }));
     }
     async connectAid(aid) {
         try {
@@ -747,7 +776,7 @@ class AunPlugin {
             const ownedSubscription = this.ownedProfiles && !this.config.owner_watch_aids?.includes(aid)
                 ? client.on("owned_agentmd.changed", payload => this.onOwnedProfile(aid, payload)) : undefined;
             const subscription = this.bindings[aid]
-                ? client.on("message.received", (payload) => this.onMessage(payload, aid))
+                ? client.on("message.received", (payload) => this.enqueueMessage(payload, aid))
                 : undefined;
             this.clients.set(aid, { client, subscription, ownedSubscription });
             try {
@@ -932,7 +961,7 @@ class AunPlugin {
             for (const aid of Object.keys(this.bindings)) {
                 const definitions = await this.abilityDefinitions(aid);
                 const ownerAid = this.abilityOwners[aid];
-                const ownerVerified = Boolean(session && ownerAid && this.ownerProof.verified(session, aid, ownerAid));
+                const ownerVerified = Boolean(session && ownerAid && this.isAbilityOwnerVerified(aid, ownerAid));
                 const publishAvailable = Boolean(this.context?.managementActor?.(request) && ownerVerified && this.context?.callPluginAbility && this.abilityOperations && !this.abilityAuditUnavailable);
                 result[aid] = { agent: this.bindings[aid], selected: this.abilitySelections[aid] ?? [], definitions, published: Object.keys(this.abilityLedgers[aid] ?? {}).length > 0, pluginVersion: this.context?.pluginVersion?.(this.bindings[aid]), ownerAid, ownerVerified, publishAvailable, reason: publishAvailable ? "需本机已认证管理会话，每次执行仍须明确批准。" : "逐次 Owner 确认需本机已认证管理会话，并验证明确配置的 Owner AID；已有索引仍可撤销。" };
             }
@@ -957,10 +986,10 @@ class AunPlugin {
             if (paths.length) {
                 const session = this.context?.managementSession?.(request);
                 const owner = this.abilityOwners[aid];
-                if (!session || !owner || !this.ownerProof.verified(session, aid, owner) || !this.context?.callPluginAbility || !this.abilityOperations || this.abilityAuditUnavailable)
+                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.ownerProof.verified(session, aid, owner) || this.abilityOwners[aid] !== owner || this.revokingAbilityAids.has(aid))
+                    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)
@@ -1000,6 +1029,8 @@ class AunPlugin {
             const ownerAid = typeof body.ownerAid === "string" ? body.ownerAid.trim() : "";
             if (!aidPattern.test(aid) || !this.bindings[aid] || !aidPattern.test(ownerAid))
                 return this.json(response, 400, { error: "需要已关联的 Provider AID 和明确指定的 Owner AID" });
+            if (this.isAbilityOwnerVerified(aid, ownerAid))
+                return this.json(response, 200, { ok: true, aid, ownerAid, alreadyVerified: true });
             if (this.abilityOwners[aid] !== ownerAid) {
                 this.revokingAbilityAids.add(aid);
                 this.abilityRevisions.set(aid, (this.abilityRevisions.get(aid) ?? 0) + 1);
@@ -1007,12 +1038,16 @@ class AunPlugin {
                 try {
                     await this.invalidateAbilityOperations(aid);
                     const previous = this.abilityOwners;
+                    const previousVerifications = this.abilityOwnerVerifications;
                     this.abilityOwners = { ...previous, [aid]: ownerAid };
+                    this.abilityOwnerVerifications = { ...previousVerifications };
+                    delete this.abilityOwnerVerifications[aid];
                     try {
                         await this.persist();
                     }
                     catch (error) {
                         this.abilityOwners = previous;
+                        this.abilityOwnerVerifications = previousVerifications;
                         throw error;
                     }
                 }
@@ -1021,7 +1056,7 @@ class AunPlugin {
                 }
             }
             const challenge = this.ownerProof.start(session, aid, ownerAid);
-            await this.callAunWithRecovery(aid, { to: ownerAid, encrypt: true, payload: { type: "text", text: `请在本次管理会话发起后回复以下指令，证明你控制 Owner AID。此操作只验证身份，不批准任何能力调用：\n/ability-owner ${challenge.nonce}` } });
+            await this.callAunWithRecovery(aid, { to: ownerAid, encrypt: true, payload: { type: "text", text: `AUN Ability 管理授权确认\nProvider AID：${aid}\nOwner AID：${ownerAid}\n用途：管理本 Provider 已公开的 Ability，并逐项确认能力调用。\n请直接回复：确认\n确认截止：${new Date(challenge.expiresAt).toLocaleString("zh-CN")}（最长 12 小时，受发起管理会话有效期限制）。\n此操作只验证 Owner 身份，不批准任何能力调用。` } });
             this.context?.logger.info("AUN Owner 会话验证已发起，需本机已认证管理会话", { aid, ownerAid });
             this.json(response, 200, { ok: true, aid, ownerAid, expiresAt: challenge.expiresAt });
         }
@@ -1054,7 +1089,7 @@ class AunPlugin {
             if (!original)
                 return this.json(response, 404, { error: "能力操作不存在" });
             const ownerAid = this.abilityOwners[original.providerAid];
-            if (!ownerAid || !this.ownerProof.verified(session, original.providerAid, ownerAid))
+            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: "确认指纹与待确认请求不一致" });
@@ -1065,7 +1100,7 @@ class AunPlugin {
                 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.ownerProof.verified(session, original.providerAid, ownerAid))
+            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;
@@ -1075,10 +1110,12 @@ class AunPlugin {
                 let handlerAuthorized = false;
                 try {
                     const failure = await this.abilityInvocationFailure(entry.providerAid, entry.authenticatedCaller, entry.path, entry.definitionId, entry.params);
-                    const expired = Date.now() >= entry.expiresAt;
+                    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.ownerProof.verified(session, 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 ? "message_expired" : failure?.code ?? (invalidated ? "provider_invalidated" : "permission_denied"), expired ? "调用已超过最晚启动时间" : failure?.message ?? "Owner 管理会话或执行目标已改变，本次能力没有执行"), execution_state: "not_executed" };
+                    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";
                     }
                     else {
@@ -1086,7 +1123,7 @@ class AunPlugin {
                         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.ownerProof.verified(session, confirmed.providerAid, ownerAid) || !this.ownerProof.verified(currentSession, confirmed.providerAid, ownerAid))
+                            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);
@@ -1102,8 +1139,8 @@ class AunPlugin {
                 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", "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" ? "调用已超过最晚启动时间" : "管理会话或 Provider 状态已改变，本次能力没有执行") : "能力执行失败，请检查 Provider 运行日志；不会自动重试"), execution_state: notExecuted ? "not_executed" : "failed" };
+                    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);
@@ -1713,17 +1750,61 @@ class AunPlugin {
             return;
         }
         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 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)) {
+                this.context?.logger.warn("AUN Owner 确认未通过验证", { traceId: inboundId, aid, sender: sender ?? "", stage: "Owner 确认校验", reason: authenticated ? "没有有效的待确认通知" : "需要配置 Owner AID 通过加密消息直接回复确认" });
+                return;
+            }
+            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);
+                }
+                catch (replyError) {
+                    this.context?.logger.warn("AUN Owner 验证结果回复失败", { aid, peer: sender, verified: false, stage: "发送 Owner 验证回执", error: safeError((0, agent_1.errorDetails)(replyError)) });
+                }
+                return;
+            }
+            try {
+                await this.sendText(aid, sender, `Owner 控制权验证成功：${aid} 的 Owner 已保存。此操作不会批准任何能力调用，请回到 ABWeb 继续操作。`, typeof body.thread_id === "string" ? body.thread_id : undefined, true);
+            }
+            catch (error) {
+                this.context?.logger.warn("AUN Owner 验证结果回复失败", { aid, peer: sender, verified: true, stage: "发送 Owner 验证回执", error: safeError((0, agent_1.errorDetails)(error)) });
+            }
+            this.context?.logger.info("AUN Owner 确认验证成功并已持久保存", { traceId: inboundId, aid, ownerAid });
+            return;
+        }
         const ownerCommand = typeof body?.text === "string" && /^\/ability-owner(?:\s|$)/.test(body.text) ? body.text.match(/^\/ability-owner ([0-9a-f]{64})$/) : undefined;
         if (typeof body?.text === "string" && /^\/ability-owner(?:\s|$)/.test(body.text)) {
-            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;
-            const verified = Boolean(ownerCommand && (envelope?.from === undefined || envelope.from === sender) && this.ownerProof.accept(aid, sender, ownerCommand[1], raw?.encrypted === true));
+            let verified = Boolean(ownerCommand && (envelope?.from === undefined || envelope.from === sender) && this.ownerProof.accept(aid, sender, ownerCommand[1], raw?.encrypted === true));
+            if (verified) {
+                const ownerAid = this.abilityOwners[aid];
+                try {
+                    if (ownerAid === sender)
+                        await this.saveAbilityOwnerVerification(aid, ownerAid);
+                    else
+                        verified = false;
+                }
+                catch (error) {
+                    verified = false;
+                    this.context?.logger.error("AUN Owner 验证状态保存失败", { traceId: inboundId, aid, stage: "保存 Owner 验证", error: safeError((0, agent_1.errorDetails)(error)) });
+                }
+            }
             this.context?.logger.info("AUN 宿主委托的 Owner 控制权验证已处理", { aid, verified });
             if (sender && raw?.encrypted === true && (envelope?.from === undefined || envelope.from === sender)) {
                 const text = verified
-                    ? `Owner 控制权验证成功：${aid} 的当前管理会话已通过验证。此操作不会批准任何能力调用，请回到 ABWeb 继续操作。`
+                    ? `Owner 控制权验证成功：${aid} 的 Owner 已保存。此操作不会批准任何能力调用，请回到 ABWeb 继续操作。`
                     : !ownerCommand
-                        ? "Owner 控制权验证失败：指令格式不正确，请复制最新验证消息中的完整 /ability-owner 指令。"
+                        ? "Owner 控制权验证失败：指令格式不正确。请在 ABWeb 重新发送确认通知，并直接回复“确认”。"
                         : "Owner 控制权验证失败：验证指令已过期、已使用，或与本次 Owner 身份不匹配。请在 ABWeb 重新发起验证，并使用指定 Owner AID 回复。";
                 try {
                     await this.sendText(aid, sender, text, typeof body.thread_id === "string" ? body.thread_id : undefined, true);
@@ -1764,14 +1845,51 @@ class AunPlugin {
             }
             return;
         }
-        const current = (pending ?? Promise.resolve()).catch(() => undefined).then(() => this.processMessage(message, aid, agentPlugin, inboundId));
+        const queuedAt = Date.now();
+        const notices = new Set();
+        let queueTimer;
+        const reportQueue = (started = false) => {
+            if (!started && notices.size)
+                return;
+            const elapsedSeconds = Math.floor((Date.now() - queuedAt) / 1000);
+            const stage = started ? "结束会话排队" : "等待同会话前序任务";
+            const text = started ? `本条消息已结束会话排队，开始处理（排队 ${elapsedSeconds} 秒）。`
+                : elapsedSeconds === 0 ? "消息已排队：当前会话仍有任务未完成，本条将按接收顺序处理。"
+                    : `本条消息仍在排队，已等待 ${elapsedSeconds} 秒；尚未转交 Agent，前序任务完成后自动处理。`;
+            const payload = {
+                type: "notice", subtype: started ? "task.dequeued" : "task.queued", severity: "info", text,
+                task_id: message.messageId || inboundId, sent_at: Date.now(),
+                ...(message.threadId ? { thread_id: message.threadId } : {}),
+                ...(message.messageId ? { ref_message_id: message.messageId } : {}),
+            };
+            this.context?.logger.info("AUN 会话排队状态", { traceId: message.messageId || inboundId, aid, peer: message.peerId, threadId: message.threadId ?? "", agentPlugin, stage, elapsedSeconds });
+            // 通知不占执行队列；notice 不会被对端作为普通任务自动互答。
+            const notice = this.callAunWithRecovery(aid, { to: message.peerId, payload, encrypt: true })
+                .then(() => undefined)
+                .catch(error => this.context?.logger.warn("AUN 排队通知发送失败", { aid, peer: message.peerId, traceId: message.messageId || inboundId, stage, error: safeError((0, agent_1.errorDetails)(error)) }))
+                .finally(() => { notices.delete(notice); });
+            notices.add(notice);
+        };
+        const current = (pending ?? Promise.resolve()).catch(() => undefined).then(() => {
+            clearInterval(queueTimer);
+            if (pending)
+                reportQueue(true);
+            return this.processMessage(message, aid, agentPlugin, inboundId);
+        });
         this.pendingMessages.set(sourceKey, current);
+        if (pending) {
+            reportQueue();
+            queueTimer = setInterval(reportQueue, 60_000);
+            queueTimer.unref();
+        }
         try {
             await current;
         }
         finally {
+            clearInterval(queueTimer);
             if (this.pendingMessages.get(sourceKey) === current)
                 this.pendingMessages.delete(sourceKey);
+            await Promise.allSettled(notices);
         }
     }
     async onFsMessage(raw, message, aid) {
@@ -1840,6 +1958,7 @@ class AunPlugin {
         const { payload, callerAid } = call;
         const rules = String(this.config.allow_from ?? "").split(",").map(value => value.trim()).filter(Boolean);
         let result;
+        let ownerNotice;
         if (rules.length && !rules.includes("*") && !rules.includes(callerAid))
             result = (0, ability_operations_1.abilityFailureResult)(payload, "permission_denied", "调用来源不在 AUN 允许名单中");
         else if (payload.ability_path === "protocol/discover") {
@@ -1895,6 +2014,8 @@ class AunPlugin {
                             else {
                                 const draft = await store.draft({ providerAid: aid, authenticatedCaller: callerAid, operationId: String(payload.operation_id), callId: String(payload.call_id), path, definitionId: String(payload.definition_id), params, effects: definition.effects, dedupeRetentionSeconds: definition.dedupe_retention_seconds, executionTarget: { pluginId, pluginVersion, ownerAid }, expiresAt, ...(payload.async === undefined ? {} : { async: payload.async }) });
                                 result = this.abilityOperationResponse(draft.entry);
+                                if (draft.created)
+                                    ownerNotice = draft.entry;
                             }
                         }
                     }
@@ -1907,6 +2028,30 @@ class AunPlugin {
             }
         }
         await this.sendAbilityResponse(aid, callerAid, result);
+        if (ownerNotice)
+            await this.notifyAbilityOwner(ownerNotice);
+    }
+    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");
+        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 申请通知" });
+        }
+        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)) });
+        }
     }
     async abilityInvocationFailure(aid, callerAid, path, definitionId, params) {
         if (this.abilityAuditUnavailable)
@@ -2038,17 +2183,18 @@ class AunPlugin {
                         groups.set(kind, group);
                     }
                     groupsCount = groups.size;
+                    const captionKind = (groupsCount === 1 ? groups.keys().next().value : undefined) ?? "attachment";
+                    const payloadText = withAttachmentDownloadLinks(text || (captionKind === "image" ? "图片已生成。" : captionKind === "video" ? "视频已生成。" : captionKind === "file" ? "文件已生成。" : "附件已生成。"), captionKind, refs);
+                    fallbackText = payloadText;
+                    fallbackLinks = attachmentDownloadLinks(refs);
                     for (const [kind, group] of groups) {
                         signal?.throwIfAborted();
-                        const payloadText = withAttachmentDownloadLinks(text || (kind === "image" ? "图片已生成。" : kind === "video" ? "视频已生成。" : "文件已生成。"), kind, group);
-                        // AUN 网页会隐藏带普通正文的单图卡片，图片说明需另发文本。
-                        const payload = { type: kind, ...(kind === "image" ? {} : { text: payloadText, format: "markdown" }), attachments: group };
+                        // AUN 网页可能隐藏附件卡片的正文；所有附件发完后只另发一次完整正文。
+                        const payload = { type: kind, attachments: group };
                         if (message.threadId)
                             payload.thread_id = message.threadId;
                         if (message.messageId)
                             payload.ref_message_id = message.messageId;
-                        fallbackText = payloadText;
-                        fallbackLinks = attachmentDownloadLinks(group);
                         sending = true;
                         // message.send 失败时可能已送达，不自动重试或降级明文，避免重复发送和泄露引用。
                         const sendResult = await this.callAunWithRecovery(aid, { to: message.peerId, payload, encrypt: true });
@@ -2057,17 +2203,17 @@ class AunPlugin {
                         this.context?.logger.info("AUN 附件消息已发送", { ...trace, stage: "发送附件消息", kind, count: group.length });
                         sending = false;
                         sent++;
-                        if (kind === "image" && payloadText) {
+                        if (sent === groupsCount && payloadText) {
                             try {
                                 signal?.throwIfAborted();
                                 const { attachments: _attachments, ...caption } = payload;
                                 const result = await this.callAunWithRecovery(aid, { to: message.peerId, payload: { ...caption, type: "text", text: payloadText, format: "markdown" }, encrypt: true });
                                 if (typeof result?.status !== "string" || !successfulSendStatuses.has(result.status))
-                                    throw new Error(`AUN 图片说明发送状态未确认：${result?.status === undefined ? "未返回状态" : String(result.status)}`);
-                                this.context?.logger.info("AUN 图片说明已发送", { ...trace, stage: "发送图片说明" });
+                                    throw new Error(`AUN 附件正文发送状态未确认：${result?.status === undefined ? "未返回状态" : String(result.status)}`);
+                                this.context?.logger.info("AUN 附件正文已发送", { ...trace, stage: "发送附件正文" });
                             }
                             catch (error) {
-                                throw new agent_1.AgentOperationError("AUN_ATTACHMENT_CAPTION_SEND_FAILED", "图片已发送，发送 AUN 图片说明（结果未确认，不自动重发）", error);
+                                throw new agent_1.AgentOperationError("AUN_ATTACHMENT_CAPTION_SEND_FAILED", "附件已发送，发送 AUN 附件正文（结果未确认，不自动重发）", error);
                             }
                         }
                     }

package/dist/src-ts/plugins/aun/peer-messaging.js

@@ -189,7 +189,7 @@ class AunPeerMessagingStore {
                 return false;
             const payload = value.payload;
             const senderDeviceId = typeof value.sender_device_id === "string" ? value.sender_device_id : undefined;
-            const requestId = payload.type === "ability" && payload.role === "result" ? payload.call_id : payload.thread_id;
+            const requestId = payload.type === "ability" && ["result", "ack"].includes(String(payload.role)) ? payload.call_id : payload.thread_id;
             if (typeof requestId !== "string")
                 return false;
             const current = this.entries.get(key(selfAid, requestId));
@@ -197,9 +197,11 @@ class AunPeerMessagingStore {
                 return false;
             const expected = current.payload;
             if (expected.type === "ability") {
-                if (payload.type !== "ability" || payload.role !== "result" || ["call_id", "operation_id", "ability_path", "definition_id"].some(field => expected[field] !== payload[field]))
+                if (payload.type !== "ability" || !["result", "ack"].includes(String(payload.role)) || ["call_id", "operation_id", "ability_path", "definition_id"].some(field => expected[field] !== payload[field]))
                     return false;
-                if (typeof payload.ok !== "boolean" || typeof payload.execution_state !== "string" || discovery(expected) && !senderDeviceId)
+                if (typeof payload.execution_state !== "string" || discovery(expected) && (!senderDeviceId || payload.role !== "result"))
+                    return false;
+                if (payload.role === "ack" ? !["pending", "pending_confirmation", "executing", "accepted"].includes(payload.execution_state) || payload.result !== undefined || payload.ok === false : typeof payload.ok !== "boolean")
                     return false;
             }
             else if (expected.type !== "text" || payload.type !== "text" || typeof payload.text !== "string")

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

@@ -82,7 +82,7 @@
       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 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");
@@ -102,7 +102,7 @@
         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 ? `等待指定 Owner 通过 AUN 回复验证指令；验证截止：${new Date(state.challengeExpiresAt).toLocaleString()}` : "当前 Owner 未验证，请发送验证。";
+        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(); };
@@ -114,9 +114,9 @@
         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: false, publishAvailable: false };
-          state.challengeExpiresAt = result.expiresAt;
-          notify("Owner 验证已发送", `验证指令已通过 AUN 发送给 ${ownerAid}。请该 Owner 在 AUN 中回复收到的 /ability-owner 指令；仅验证当前管理会话，不会执行能力。`);
+          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(); }
       };
@@ -153,17 +153,18 @@
       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)}\n过期时间: ${new Date(entry.expiresAt).toLocaleString()} (${entry.expiresAt})\n状态: ${entry.state}`; details.append(contract);
+      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 expired = !Number.isFinite(entry.expiresAt) || entry.expiresAt <= Date.now();
+        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 || expired; reject.disabled = unavailable;
-        expiry.textContent = expired ? "已过期，不能批准" : "有效期内，每次批准只执行本条请求";
+        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) => {

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

@@ -6,8 +6,8 @@
     <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 回复收到的 /ability-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>核对认证调用方、原始参数、契约指纹、影响和执行目标后，逐项批准一次或拒绝。批准只绑定表格中的完整请求；过期请求不能批准。没有当前会话的 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>
+    <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/package.json

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

package/plugin.json

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