@agentunion/fastaun 0.5.19 → 0.5.21

package/dist/client.js

@@ -26,7 +26,7 @@ import { normalizeGroupId } from './group-id.js';
 import { validateAIDFormat, validateGroupIDFormat } from './validators.js';
 import { RPCTransport } from './transport.js';
 import { AuthFlow } from './auth.js';
-import { AgentMdManager, buildDefaultAgentMd, updateOwnershipAgentMd } from './agent-md.js';
+import { AgentMdManager, buildDefaultAgentMd } from './agent-md.js';
 import { GroupIndexMetaCache } from './group-index.js';
 import { SeqTracker } from './seq-tracker.js';
 import { ClientRuntime } from './client/runtime.js';
@@ -37,7 +37,7 @@ import { LifecycleController } from './client/lifecycle.js';
 import { PeerDirectory } from './client/peers.js';
 import { RpcPipeline } from './client/rpc-pipeline.js';
 import { CollabClient } from './collab/client.js';
-import { CredentialFacade, OrgFacade, GroupFacade, MailFacade, MessageFacade, StreamFacade } from './facades.js';
+import { DebugFacade, CredentialFacade, OrgFacade, GroupFacade, MailFacade, MessageFacade, StreamFacade } from './facades.js';
 import { StorageVFS } from './storage/vfs.js';
 import { V2E2EECoordinator } from './client/v2-e2ee.js';
 import { GroupStateCoordinator } from './client/group-state.js';
@@ -47,10 +47,10 @@ import { decryptedOwnershipJsonText } from './v2/e2ee/decrypt.js';
 import { isJsonObject, ConnectionState, STATE_TO_PUBLIC, } from './types.js';
 import { AID } from './aid.js';
 import { certFingerprint, certMatchesFingerprint, normalizeFingerprintHex, publicKeyMatchesFingerprint } from './cert-utils.js';
-import { validateAgentMdDocument } from './agent-md-schema.js';
-import { OwnershipFiles, OwnershipStorageAdapter, ownershipFailure, signOwnershipFile } from './ownership-v21.js';
+import { validateAgentMdCertificate, validateAgentMdDocument } from './agent-md-schema.js';
+import { OwnershipFiles, OwnershipStorageAdapter, ownershipFailure } from './ownership-v21.js';
 import { OwnershipWorkflow } from './ownership-workflow.js';
-import { canonicalJson, createCredential, createMemberCredential, signMembershipBinding, verifyServiceEvent } from './org-protocol.js';
+import { canonicalJson, createCredential, createMemberCredential, signMembershipBinding, digest, validateMembershipBinding, verifyMembershipBinding, verifyCredentialSignature, createRepresentationProof, verifyServiceEvent, buildRequestBinding, validateRequestBinding, CredentialRenewal } from './org-protocol.js';
 function isPromiseLike(value) {
     return Boolean(value && typeof value.then === 'function');
 }
@@ -440,7 +440,7 @@ function createAgentMdManagerForRuntime(opts) {
             const target = String(aid ?? '').trim();
             const expectedFp = String(certFingerprint ?? '').trim().toLowerCase();
             const current = opts.currentAid();
-            if (current?.aid === target) {
+            if (signedAt === undefined && current?.aid === target) {
                 if (!expectedFp || certMatchesFingerprint(current.certPem, expectedFp))
                     return current;
             }
@@ -478,6 +478,7 @@ export class AUNClient {
     /** 当前 AID 值对象（新 API） */
     _currentAid = null;
     _serviceEventIdentityVersion = 0;
+    _serviceEventIdentityAbort = new AbortController();
     /** ownership 关系只在 SDK 内存中编排；服务端不保存状态机。 */
     _ownershipRecords = new Map();
     _ownershipType = 'agent';
@@ -485,7 +486,7 @@ export class AUNClient {
     _ownershipFiles = null;
     _ownershipWorkflow = null;
     _getOwnershipStorage() {
-        return this._ownershipStorage ??= new OwnershipStorageAdapter({ currentAid: () => this._aid, call: (method, params) => this.call(method, params) });
+        return this._ownershipStorage ??= new OwnershipStorageAdapter({ currentAid: () => this._aid, call: (method, params) => this.call(method, params), httpPut: (url, data, headers) => this.storage.lowlevel.httpPut(url, data, headers) });
     }
     _getOwnershipFiles() {
         return this._ownershipFiles ??= new OwnershipFiles({
@@ -494,10 +495,10 @@ export class AUNClient {
             currentType: () => this.getType(),
             now: () => Math.trunc(Date.now() / 1000),
             readAgentMdFresh: (subAid) => this._agentMdManager.readOwnershipFresh(subAid),
-            submitAgentMdRaw: (subAid, raw, condition) => this._agentMdManager.submitOwnershipRaw(subAid, raw, condition),
+            submitAgentMdRaw: (subAid, raw, condition, assertActive) => this._agentMdManager.submitOwnershipRaw(subAid, raw, condition, assertActive),
             readOwnerMd: (ownerAid, subAid) => this._getOwnershipStorage().readOwnerMd(ownerAid, subAid),
-            writeOwnerMd: (ownerAid, subAid, raw, revision) => this._getOwnershipStorage().writeOwnerMd(ownerAid, subAid, raw, revision),
-            deleteOwnerMd: (ownerAid, subAid, revision) => this._getOwnershipStorage().deleteOwnerMd(ownerAid, subAid, revision),
+            writeOwnerMd: (ownerAid, subAid, raw, original, assertActive) => this._getOwnershipStorage().writeOwnerMd(ownerAid, subAid, raw, original, assertActive),
+            deleteOwnerMd: (ownerAid, subAid) => this._getOwnershipStorage().deleteOwnerMd(ownerAid, subAid),
             resolveCertificate: async (aid, fingerprint, purpose) => this._auth.resolveOwnershipCertificate(await this._resolveOwnershipCertificateGateway(aid), aid, fingerprint, purpose),
         });
     }
@@ -549,6 +550,188 @@ export class AUNClient {
         await this._resumeRegistrationIntent();
         await this._resumeOwnership();
     }
+    _credentialRenewal;
+    _credentialRenewalTimer = null;
+    _credentialRenewalAbort = null;
+    _credentialRenewalScan = Promise.resolve();
+    _getCredentialRenewal() {
+        return this._credentialRenewal ??= new CredentialRenewal({
+            currentAid: () => this._aid ?? '',
+            atomicCheckpointSave: () => this._tokenStore instanceof LocalTokenStore,
+            load: (aid) => (this._tokenStore._loadMetadataStrict?.(aid) ?? this._tokenStore.loadMetadata?.(aid))?.credential_renewals_v1 ?? {},
+            ...(typeof this._tokenStore._loadMetadataStrict === 'function' ? {
+                loadRevocations: (aid) => this._tokenStore._loadMetadataStrict(aid)?.credential_revocations_v1 ?? {},
+                saveRevocations: (aid, state, guard) => {
+                    if (guard && !guard.current())
+                        throw new ValidationError('credential revocation synchronization was superseded');
+                    this._tokenStore.saveMetadata?.(aid, { credential_revocations_v1: state });
+                },
+            } : {}),
+            save: (aid, records, guard) => {
+                const version = this._serviceEventIdentityVersion;
+                const current = () => version === this._serviceEventIdentityVersion && aid === this._aid && (!guard || guard.current());
+                if (!current())
+                    throw new ValidationError('membership event receiver identity changed');
+                const saved = this._tokenStore instanceof LocalTokenStore ? records : Object.fromEntries(Object.entries(records).map(([cid, value]) => {
+                    const record = { ...value };
+                    for (const key of ['submitted_at', 'submission_hash', 'registration_submitted_at', 'registration_submission_hash'])
+                        delete record[key];
+                    return [cid, record];
+                }));
+                this._tokenStore.saveMetadata?.(aid, { credential_renewals_v1: saved });
+                if (!current())
+                    throw new ValidationError('membership event receiver identity changed');
+            },
+            signer: (aid, guard) => this._credentialRenewalSigner(aid, guard),
+            certificate: (aid, fingerprint, signedAt) => signedAt === undefined
+                ? this._fetchServiceEventCertificate(aid, fingerprint) : this._fetchPeerCert(aid, fingerprint, undefined, signedAt),
+            call: (method, params, onSent) => {
+                if (!onSent)
+                    return this._rpcPipeline.call(method, params);
+                const version = this._serviceEventIdentityVersion, aid = this._aid;
+                return this._rpcPipeline['_callWithSent'](method, params, async () => {
+                    if (version !== this._serviceEventIdentityVersion || aid !== this._aid)
+                        throw new ValidationError('credential sender identity changed');
+                    await onSent();
+                });
+            },
+            send: (to, payload) => this.call('message.send', { to, encrypt: true, payload }),
+        });
+    }
+    _assertCredentialNotRevoked(credential, proofChain) {
+        const version = this._serviceEventIdentityVersion, aid = this._aid;
+        const current = () => { if (aid !== this._aid || version !== this._serviceEventIdentityVersion)
+            throw new ValidationError('credential receiver identity changed'); };
+        this._getCredentialRenewal()._assertNotRevoked(credential, proofChain);
+        current();
+        return current;
+    }
+    async _credentialRenewalSigner(aid, guard) {
+        const check = () => { if (guard && !guard.current())
+            throw new ValidationError('credential renewal was superseded'); };
+        check();
+        const stored = this._aidStore?.load(aid);
+        let identity = aid === this._aid && this._identity?.private_key_pem
+            ? AID._create({ aid, aunPath: this._configModel.aunPath, certPem: String(this._identity.cert ?? this._currentAid?.certPem ?? ''), privateKeyPem: String(this._identity.private_key_pem), certValid: true, privateKeyValid: true })
+            : stored?.ok ? stored.data.aid : undefined;
+        if (!identity?.isPrivateKeyValid())
+            return null;
+        const certificate = new crypto.X509Certificate(identity.certPem);
+        const end = Date.parse(certificate.validTo), start = Date.parse(certificate.validFrom);
+        if (end > Date.now() && end - Date.now() < (end - start) / 2 && this._aidStore) {
+            const renewed = await (guard ? this._aidStore._renewCert(aid, guard) : this._aidStore.renewCert(aid));
+            check();
+            if (!renewed.ok)
+                throw new ValidationError(renewed.error.message);
+            const loaded = this._aidStore.load(aid);
+            if (!loaded.ok)
+                throw new ValidationError(loaded.error.message);
+            identity = loaded.data.aid;
+            if (aid === this._aid && this._identity) {
+                this._identity.cert = identity.certPem;
+                this._currentAid = identity;
+            }
+        }
+        return identity;
+    }
+    _currentCredential(input) {
+        const records = this._tokenStore.loadMetadata?.(this._aid ?? '')?.credential_renewals_v1 ?? {};
+        let cid = typeof input === 'string' ? input : String(input.cid);
+        const seen = new Set();
+        while (records[cid]?.successor_cid && !seen.has(cid)) {
+            seen.add(cid);
+            cid = String(records[cid].successor_cid);
+        }
+        return records[cid] ? structuredClone(records[cid]) : null;
+    }
+    _credentialCurrent(input) {
+        return this._getCredentialRenewal().current(input);
+    }
+    async _resumeCredentialRenewalAfterConnect(guard) {
+        if (!this._aid || (guard && !guard.current()))
+            return;
+        await this._safeAsync(guard ? this._credentialRenewalSigner(this._aid, guard) : this._credentialRenewalSigner(this._aid));
+        if (!guard || guard.current())
+            await this._safeAsync(this._getCredentialRenewal()._syncRevocations?.(guard) ?? Promise.resolve());
+        if (!guard || guard.current())
+            await this._getCredentialRenewal().resume(guard);
+    }
+    _startCredentialRenewal() {
+        this._stopCredentialRenewal();
+        const aid = this._aid, version = this._serviceEventIdentityVersion;
+        if (!aid || !['ready', 'connected'].includes(this._state) || this._closing || this._disconnecting)
+            return;
+        const abort = new AbortController();
+        this._credentialRenewalAbort = abort;
+        const current = () => this._credentialRenewalAbort === abort && !abort.signal.aborted && aid === this._aid && version === this._serviceEventIdentityVersion && ['ready', 'connected'].includes(this._state) && !this._closing && !this._disconnecting;
+        const guard = { current, signal: abort.signal };
+        const scan = async () => {
+            const task = this._credentialRenewalScan.then(async () => {
+                if (!current())
+                    return;
+                await this._resumeCredentialRenewalAfterConnect(guard);
+            });
+            this._credentialRenewalScan = task.catch(() => { });
+            await this._safeAsync(task);
+            if (current())
+                this._credentialRenewalTimer = setTimeout(() => { void scan(); }, 60_000);
+        };
+        void scan();
+    }
+    _stopCredentialRenewal() {
+        this._credentialRenewalAbort?.abort();
+        this._credentialRenewalAbort = null;
+        if (this._credentialRenewalTimer !== null)
+            clearTimeout(this._credentialRenewalTimer);
+        this._credentialRenewalTimer = null;
+    }
+    _rememberCredential(credential, material, certificate) {
+        if (!material.long_term && certificate) {
+            const cert = new crypto.X509Certificate(typeof certificate === 'string' && !certificate.includes('-----BEGIN CERTIFICATE-----') ? Buffer.from(certificate, 'base64') : certificate);
+            const parent = Array.isArray(credential.proof_chain) ? credential.proof_chain[0] : undefined;
+            const certificateEnd = Math.floor(Date.parse(cert.validTo) / 1000);
+            const defaultEnd = credential.parent != null && isJsonObject(parent) && typeof parent.exp === 'number'
+                ? Math.min(certificateEnd, Number(parent.exp)) : certificateEnd;
+            material = { ...material, long_term: credential.exp === defaultEnd };
+        }
+        this._safeAsync(this._getCredentialRenewal().remember(credential, material));
+    }
+    async _verifyIncomingServiceEvent(event, payload) {
+        const targetAid = this._identity?.aid ?? '';
+        const version = this._serviceEventIdentityVersion;
+        const signal = this._serviceEventIdentityAbort.signal;
+        const expiresAt = Number(payload?.expires_at);
+        const current = () => version === this._serviceEventIdentityVersion && targetAid === (this._identity?.aid ?? '') && Date.now() / 1000 < expiresAt;
+        const verified = await verifyServiceEvent(event, payload, { targetAid, resolveEventCertificate: (aid, fingerprint) => this._fetchServiceEventCertificate(aid, fingerprint), resolveCredentialService: this.resolveCredentialService });
+        if (!current())
+            throw new ValidationError('service event receiver identity changed');
+        if (event.replace(/^event\//, '') === 'org.member.changed' && isJsonObject(payload) && Object.hasOwn(payload, 'membership_package')) {
+            await this._getCredentialRenewal().importMembershipPackage(payload, { current, signal });
+            if (!current())
+                throw new ValidationError('service event receiver identity changed');
+        }
+        return verified;
+    }
+    async _handleCredentialRenewal(message) {
+        if (!isJsonObject(message))
+            return false;
+        const envelope = message;
+        const content = 'payload' in envelope ? envelope.payload : envelope;
+        const payload = decryptedOwnershipJsonText(content) ?? content;
+        let parsed = payload;
+        if (typeof payload === 'string') {
+            try {
+                parsed = JSON.parse(payload);
+            }
+            catch {
+                return false;
+            }
+        }
+        if (!isJsonObject(parsed) || !['credential.renewal.request', 'credential.renewal.result'].includes(String(parsed.type)))
+            return false;
+        await this._safeAsync(this._getCredentialRenewal().receive(String(envelope.from ?? envelope.from_aid ?? envelope.sender_aid ?? ''), parsed));
+        return true;
+    }
     async _resumeRegistrationIntent() {
         const intent = this._tokenStore.loadMetadata?.(this._aid)?.registration_intent;
         if (['group', 'org'].includes(String(intent?.type ?? this.getType())))
@@ -598,11 +781,13 @@ export class AUNClient {
     _defaultConnectDeliveryMode;
     /** peer 证书缓存 */
     _certCache = new Map();
+    _certFetchInFlight = new Map();
     _agentMdManager;
     _aidStore;
     _groupIdentityOperations = new Map();
     _groupIndexMetaCache = new GroupIndexMetaCache();
     /** 消息序列号跟踪器（群消息 + P2P 空洞检测） */
+    _p2pPeerPullEnabled = true;
     _seqTracker = new SeqTracker();
     _seqTrackerContext = null;
     /** 惰性群同步：已同步过的 group_id 集合 */
@@ -685,6 +870,7 @@ export class AUNClient {
     _storage;
     _collab;
     _message;
+    _debug;
     _mail;
     _group;
     _stream;
@@ -725,7 +911,7 @@ export class AUNClient {
         if (debugFlag) {
             this._clientLog.info(`AUNClient initialized (debug=true, aunPath=${this._configModel.aunPath})`);
         }
-        this._dispatcher = new EventDispatcher(this._logger.for('aun_core.events'), () => this._identity?.aid ?? '');
+        this._dispatcher = new EventDispatcher(this._logger.for('aun_core.events'), () => this._identity?.aid ?? '', () => this._ensureReadStateIdentity());
         const dnsNet = new DnsResilientNet({
             verifySsl: this._configModel.verifySsl,
             logger: this._clientLog,
@@ -771,7 +957,7 @@ export class AUNClient {
             },
             auth: () => this._auth,
             tokenStore: () => this._tokenStore,
-            fetchPeerCert: (target, certFingerprint, signedAt) => this._fetchPeerCert(target, certFingerprint || undefined, undefined, signedAt),
+            fetchPeerCert: (target, certFingerprint, signedAt) => this._fetchPeerCert(target, certFingerprint || undefined, undefined, signedAt, true),
             resolveEntityOwner: (target, type) => this._resolveEntityAgentMdOwner(target, type),
             fetchEntityIdentity: (target, type) => this._freshEntityCertificate(target, type),
             fetchEntitySigner: (target, fingerprint) => this._freshEntitySigner(target, fingerprint),
@@ -784,9 +970,10 @@ export class AUNClient {
             dnsNet,
         });
         this._transport.setProtocolMetaObserver((meta) => this._observeRpcMeta(meta));
-        this._transport.setServiceEventVerifier((event, payload) => verifyServiceEvent(event, payload, { targetAid: this._identity?.aid ?? '', resolveEventCertificate: (aid, fingerprint) => this._fetchServiceEventCertificate(aid, fingerprint), resolveCredentialService: this.resolveCredentialService }), () => this._identity?.aid ?? '', () => this._serviceEventIdentityVersion);
+        this._transport.setServiceEventVerifier((event, payload) => this._verifyIncomingServiceEvent(event, payload), () => this._identity?.aid ?? '', () => this._serviceEventIdentityVersion);
         this._transport.setProtocolDisconnectCallback((err, closeCode) => this._handleTransportDisconnect(err, closeCode));
         this._transport._onForegroundDrained = () => this._delivery.onForegroundPullsDrained();
+        this._transport._onRpcResponse = () => this._delivery.requestBackgroundPullRecovery();
         this._runtime = new ClientRuntime(this);
         this._identityRuntime = new IdentityRuntimeManager(this._runtime);
         this._peerDirectory = new PeerDirectory(this._runtime);
@@ -816,7 +1003,8 @@ export class AUNClient {
         this._dispatcher.subscribeProtocol('_raw.message.read_changed', (data) => this._onRawReadChanged(data, 'p2p'));
         // V2 P2P 推送通知：收到通知后自动走 message.v2.pull 拉取并解密
         this._dispatcher.subscribeProtocol('_raw.peer.v2.message_received', (data) => {
-            const ns = this._aid ? `p2p:${this._aid}` : '';
+            const sender = isJsonObject(data) ? String(data.sender_aid ?? '') : '';
+            const ns = this._p2pPeerPullEnabled ? (sender ? this._delivery.peerNamespace(sender) : '') : this._aid ? `p2p:${this._aid}` : '';
             const hasInline = isJsonObject(data)
                 && isJsonObject(data.inline_message);
             const inlineGeneration = hasInline ? this._delivery.captureInlineAckGeneration() : undefined;
@@ -895,6 +1083,21 @@ export class AUNClient {
             this._collab = new CollabClient(this);
         return this._collab;
     }
+    get debug() {
+        if (!this._debug)
+            this._debug = new DebugFacade(this, async (operation) => {
+                const transport = this._transport;
+                const previous = transport.getTraceMode();
+                transport.setTraceMode('diag');
+                try {
+                    return await operation();
+                }
+                finally {
+                    transport.setTraceMode(previous);
+                }
+            });
+        return this._debug;
+    }
     /** Message facade 入口 */
     get message() {
         if (!this._message)
@@ -973,6 +1176,7 @@ export class AUNClient {
     }
     async bindOwneraid(ownerAid) { return this._getOwnershipWorkflow().bindOwneraid(ownerAid); }
     async bindSubaid(subAid) { return this._getOwnershipWorkflow().bindSubaid(subAid); }
+    async resetOwnershipTask() { return this._getOwnershipWorkflow().resetOwnershipTask(); }
     async releaseSubaid(subAid) { return this._getOwnershipWorkflow().releaseSubaid(subAid); }
     async transferSubaid(subAid, newOwnerAid) { return this._getOwnershipWorkflow().transferSubaid(subAid, newOwnerAid); }
     async checkOwnershipConsensus(subAid) { return this._getOwnershipWorkflow().checkOwnershipConsensus(subAid); }
@@ -1159,7 +1363,7 @@ export class AUNClient {
             },
             auth: () => this._auth,
             tokenStore: () => this._tokenStore,
-            fetchPeerCert: (target, certFingerprint, signedAt) => this._fetchPeerCert(target, certFingerprint || undefined, undefined, signedAt),
+            fetchPeerCert: (target, certFingerprint, signedAt) => this._fetchPeerCert(target, certFingerprint || undefined, undefined, signedAt, true),
             resolveEntityOwner: (target, type) => this._resolveEntityAgentMdOwner(target, type),
             fetchEntityIdentity: (target, type) => this._freshEntityCertificate(target, type),
             fetchEntitySigner: (target, fingerprint) => this._freshEntitySigner(target, fingerprint),
@@ -1172,14 +1376,18 @@ export class AUNClient {
             dnsNet,
         });
         this._transport.setProtocolMetaObserver((meta) => this._observeRpcMeta(meta));
-        this._transport.setServiceEventVerifier((event, payload) => verifyServiceEvent(event, payload, { targetAid: this._identity?.aid ?? '', resolveEventCertificate: (aid, fingerprint) => this._fetchServiceEventCertificate(aid, fingerprint), resolveCredentialService: this.resolveCredentialService }), () => this._identity?.aid ?? '', () => this._serviceEventIdentityVersion);
+        this._transport.setServiceEventVerifier((event, payload) => this._verifyIncomingServiceEvent(event, payload), () => this._identity?.aid ?? '', () => this._serviceEventIdentityVersion);
         this._transport.setProtocolDisconnectCallback((err, closeCode) => this._handleTransportDisconnect(err, closeCode));
         this._transport._onForegroundDrained = () => this._delivery.onForegroundPullsDrained();
+        this._transport._onRpcResponse = () => this._delivery.requestBackgroundPullRecovery();
     }
     loadIdentity(aid) {
         const previousAid = this._aid;
         this._identityRuntime.loadIdentity(aid);
+        this._stopCredentialRenewal();
         this._serviceEventIdentityVersion++;
+        this._serviceEventIdentityAbort.abort();
+        this._serviceEventIdentityAbort = new AbortController();
         this._ensureReadStateIdentity();
         if (previousAid !== this._aid) {
             this._ownershipRecords.clear();
@@ -1287,6 +1495,7 @@ export class AUNClient {
             ? this._ensureReadStateIdentity() : null;
         try {
             const result = await this._rpcPipeline.call(method, params);
+            await this._safeAsync(this._getCredentialRenewal().observe(method, params ?? {}, result));
             if (readIdentity !== null && readIdentity === this._ensureReadStateIdentity())
                 this._observeReadStateResult(method, result, params ?? {});
             return result;
@@ -1316,6 +1525,13 @@ export class AUNClient {
             const groupId = String(params.group_id ?? params.groupId ?? params.group_aid ?? params.groupAid ?? fallback).trim();
             if (!groupId || !store)
                 return false;
+            const groupManager = store._agentMdManager ?? this._agentMdManager;
+            const keystore = store._keystore;
+            let pendingBind = keystore?.loadPendingGroupBind?.(`bind:${groupId}`);
+            if (!pendingBind?.public_key_der_b64 || !pendingBind?.private_key_pem)
+                pendingBind = keystore?.loadPendingGroupBind?.(groupId);
+            if (groupManager.pendingUpload(fallback) && (!pendingBind?.public_key_der_b64 || !pendingBind?.private_key_pem))
+                return false;
             try {
                 await this._runGroupIdentityOperation(groupId, () => this.bindGroupAid({ group_id: groupId }, { aidStore: store }));
             }
@@ -1333,6 +1549,11 @@ export class AUNClient {
             const loaded = store.load(groupAid);
             if (!loaded.ok || !loaded.data?.aid?.isPrivateKeyValid())
                 return false;
+            const groupManager = store._agentMdManager ?? this._agentMdManager;
+            if (groupManager.pendingUpload(groupAid))
+                return false;
+            if (String((groupManager._loadRecord?.(groupAid, true) ?? groupManager.loadRecord(groupAid))?.local_draft_content ?? ''))
+                return false;
             await this._runGroupIdentityOperation(groupAid, () => this._uploadGroupAgentMd(store, groupAid, {}, {}));
             return true;
         }
@@ -1348,17 +1569,15 @@ export class AUNClient {
         const aid = this._aid;
         if (!aid || !this._currentAid)
             return false;
-        const observed = await this._getOwnershipFiles().readAgent(aid);
-        if (observed.exists)
+        const observed = await this._agentMdManager.readAgentMdFresh(aid);
+        if (observed.exists || String(this._agentMdManager._loadRecord?.(aid, true)?.local_draft_content ?? this._agentMdManager.loadRecord(aid)?.local_draft_content ?? '') || this._agentMdManager.pendingUpload(aid))
             return false;
         let agentMd = buildDefaultAgentMd(aid, { type: this.getType() });
         try {
             agentMd = this._agentMdManager.readContent(aid) || agentMd;
         }
         catch { }
-        const payload = updateOwnershipAgentMd(agentMd, {});
-        const raw = signOwnershipFile(this._currentAid, payload.endsWith('\n') || payload.endsWith('\r') ? payload : `${payload}\n`, 'agent');
-        await this._agentMdManager.submitOwnershipRaw(aid, raw, { if_none_match: '*' });
+        await this._agentMdManager.upload(agentMd, { if_none_match: '*' });
         return true;
     }
     async _checkIdentityAdmissionAfterConnect() {
@@ -1412,13 +1631,18 @@ export class AUNClient {
                         await this.completeGroupTransfer({ group_id: groupId, group_aid: groupAid }, { aidStore: store });
                         return;
                     }
+                    const groupManager = store._agentMdManager ?? this._agentMdManager;
+                    if (groupManager.pendingUpload(groupAid))
+                        return;
+                    if (String((groupManager._loadRecord?.(groupAid, true) ?? groupManager.loadRecord(groupAid))?.local_draft_content ?? '')) {
+                        await this._agentMdManager.check(groupAid);
+                        return;
+                    }
                     const loaded = store.load(groupAid);
                     if (!loaded.ok || !loaded.data?.aid?.isPrivateKeyValid()) {
                         await this.bindGroupAid({ group_id: groupId, group_aid: groupAid }, { aidStore: store });
                         return;
                     }
-                    if (await this._resumeGroupAgentMdUpload(store, groupAid))
-                        return;
                     const checked = await this._agentMdManager.check(groupAid);
                     if (!checked.remote_found) {
                         await this._uploadGroupAgentMd(store, groupAid, {}, {});
@@ -1449,12 +1673,45 @@ export class AUNClient {
                 this._groupIdentityOperations.delete(key);
         }
     }
+    async _resumeOrgRequest(method, params, target) {
+        const binding = params.request_binding;
+        const now = Math.trunc(Date.now() / 1000);
+        if (!isJsonObject(binding) || now < Number(binding.exp))
+            return params;
+        const credentials = isJsonObject(params.credentials) ? params.credentials : {};
+        const credential = ['member_credential', 'approval_credential', 'audit_credential'].map((field) => credentials[field]).find(isJsonObject) ?? params.credential_template;
+        const cid = isJsonObject(credential) ? String(credential.cid) : '';
+        validateRequestBinding(binding, method, target, params, cid, String(params.nonce), String(params.request_id), Number(binding.iat));
+        let exp = now + 300;
+        for (const material of [credential, ...Object.values(credentials).filter((value) => isJsonObject(value) && value.ver === 'aun-cap/1'), ...[params, params.previous_owner, params.new_owner].filter(isJsonObject).flatMap((value) => ['membership_binding', 'credential_template', 'registration_authorization'].map((field) => value[field]))]) {
+            if (isJsonObject(material)) {
+                if (!Number.isInteger(material.exp) || Number(material.exp) <= now)
+                    throw new ValidationError('Org recovery authorization material has expired');
+                exp = Math.min(exp, Number(material.exp));
+            }
+        }
+        const refreshed = { ...params, request_binding: buildRequestBinding(method, target, params, cid, String(params.nonce), String(params.request_id), now, exp) };
+        delete refreshed.client_signature;
+        if (isJsonObject(credentials.representation_proof)) {
+            if (!this._currentAid || !isJsonObject(credential))
+                throw new ValidationError('Org recovery representation signer is unavailable');
+            refreshed.credentials = { ...credentials, representation_proof: createRepresentationProof(credential, refreshed, refreshed.request_binding, this._currentAid, refreshed.proof_chain) };
+        }
+        return refreshed;
+    }
     async createOrg(params = {}, options = {}) {
         const store = options.aidStore;
         const owner = this._currentAid;
         const orgAid = String(params.org_id ?? '').trim();
         if (!store || !owner?.isPrivateKeyValid() || !orgAid)
             throw new ValidationError('createOrg requires aidStore, org_id and current owner identity');
+        const tokens = store._tokenStore;
+        const inputHash = crypto.createHash('sha256').update(canonicalJson(params)).digest('hex');
+        let checkpoint = (typeof tokens._loadMetadataStrict === 'function' ? tokens._loadMetadataStrict(orgAid) : tokens.loadMetadata(orgAid))?.org_identity_creation;
+        if (checkpoint != null && !isJsonObject(checkpoint))
+            throw ownershipFailure('persistence_unavailable', 'Org creation checkpoint is invalid');
+        if (checkpoint && (checkpoint.owner_aid !== owner.aid || checkpoint.input_hash !== inputHash))
+            throw ownershipFailure('conflict', 'pending Org creation context changed');
         this._aidStore = store;
         let identity = store.load(orgAid);
         if (!identity.ok) {
@@ -1466,18 +1723,13 @@ export class AUNClient {
         if (!identity.ok)
             throw ownershipFailure('unavailable', identity.error.message, true);
         const target = options.serviceAid ?? `org.${orgAid.slice(orgAid.indexOf('.') + 1)}`;
-        const tokens = store._tokenStore;
-        const inputHash = crypto.createHash('sha256').update(canonicalJson(params)).digest('hex');
-        let checkpoint = tokens.loadMetadata(orgAid)?.org_identity_creation;
-        if (checkpoint && (checkpoint.owner_aid !== owner.aid || checkpoint.input_hash !== inputHash))
-            throw ownershipFailure('conflict', 'pending Org creation context changed');
         if (!checkpoint) {
             const prepared = this.org.prepareRequest('org.lifecycle.create', { ...params, owner_aid: owner.aid }, target, owner, { orgSigner: identity.data.aid });
             checkpoint = { owner_aid: owner.aid, input_hash: inputHash, source_params: params, prepared, phase: 'create' };
             tokens.saveMetadata(orgAid, { org_identity_creation: checkpoint });
         }
         if (checkpoint.phase === 'create') {
-            const result = await this.call('org.lifecycle.create', checkpoint.prepared);
+            const result = await this.call('org.lifecycle.create', await this._resumeOrgRequest('org.lifecycle.create', checkpoint.prepared, target));
             checkpoint = { ...checkpoint, result, phase: 'upload' };
             tokens.saveMetadata(orgAid, { org_identity_creation: checkpoint });
         }
@@ -1491,9 +1743,11 @@ export class AUNClient {
         if (typeof keyStore?.listIdentities !== 'function' || typeof tokens?.loadMetadata !== 'function')
             return;
         for (const aid of keyStore.listIdentities()) {
-            const metadata = tokens.loadMetadata(aid);
+            const metadata = typeof tokens._loadMetadataStrict === 'function' ? tokens._loadMetadataStrict(aid) : tokens.loadMetadata(aid);
             const creation = metadata?.org_identity_creation;
             const transfer = metadata?.org_identity_transfer;
+            if (creation != null && !isJsonObject(creation) || transfer != null && !isJsonObject(transfer))
+                throw ownershipFailure('persistence_unavailable', 'Org identity checkpoint is invalid');
             try {
                 if (creation?.owner_aid === this._aid) {
                     await this.createOrg(creation.source_params, { aidStore: store });
@@ -1503,18 +1757,46 @@ export class AUNClient {
                     await this.completeOrgTransfer(transfer.source_params, { aidStore: store });
                     continue;
                 }
-                const pending = store._agentMdManager.pendingUpload(aid);
-                if (!pending)
-                    continue;
-                const fields = validateAgentMdDocument(pending.content, { expectedAid: aid }).frontmatter;
-                if (fields.type === 'org' && fields.owner === this._aid)
-                    await this._resumeGroupAgentMdUpload(store, aid);
             }
             catch (error) {
                 this._clientLog.warn(`post-connect Org identity recovery failed: aid=${aid} err=${formatCaughtError(error)}`);
             }
         }
     }
+    async _verifyOrgTransferMaterials(params, ownerAid) {
+        const orgAid = String(params.org_id);
+        const previous = params.previous_owner;
+        const next = params.new_owner;
+        const binding = previous.membership_binding;
+        const nextBinding = next.membership_binding;
+        const credential = previous.credential_template;
+        const ext = isJsonObject(credential.ext) ? credential.ext : {};
+        const capability = Array.isArray(credential.cap) && credential.cap.length === 1 && isJsonObject(credential.cap[0]) ? credential.cap[0] : {};
+        const now = Math.trunc(Date.now() / 1000);
+        if (binding.org_id !== orgAid || nextBinding.org_id !== orgAid || binding.member_aid === ownerAid || nextBinding.member_aid !== ownerAid
+            || binding.role !== 'member' || nextBinding.role !== 'owner' || digest(previous.terms) !== binding.terms_hash || digest(next.terms) !== nextBinding.terms_hash
+            || !Number.isSafeInteger(nextBinding.iat) || !Number.isSafeInteger(nextBinding.exp) || Number(nextBinding.iat) > now || Number(nextBinding.exp) <= now
+            || credential.iss !== orgAid || credential.sub !== binding.member_aid || credential.parent != null || credential.delegate !== false
+            || ext.credential_type !== 'member' || ext.bound_to_membership !== true || ext.org_id !== orgAid || ext.membership_id !== binding.membership_id
+            || ext.binding_version !== binding.binding_version || ext.membership_terms_hash !== binding.terms_hash
+            || capability.ns !== 'org' || capability.action !== 'role.member' || capability.resource !== orgAid)
+            throw ownershipFailure('invalid', 'Org transfer membership materials do not match');
+        validateMembershipBinding(binding);
+        const certificates = new Map();
+        for (const [aid, signature] of [[binding.member_aid, binding.member_signature], [orgAid, binding.org_signature], [orgAid, credential.signature]]) {
+            if (!isJsonObject(signature))
+                throw ownershipFailure('invalid', 'Org transfer membership materials do not match');
+            const fingerprint = String(signature.cert_fingerprint);
+            const certificate = await this._auth.resolveOwnershipCertificate(await this._resolveOwnershipCertificateGateway(String(aid)), String(aid), fingerprint);
+            certificates.set(fingerprint, certificate.cert_pem);
+        }
+        const resolve = (fingerprint) => certificates.get(fingerprint);
+        const checkedAt = Math.trunc(Date.now() / 1000);
+        verifyMembershipBinding(binding, resolve, checkedAt, orgAid);
+        verifyCredentialSignature(credential, resolve, checkedAt, orgAid);
+        if (Number(nextBinding.exp) <= checkedAt)
+            throw ownershipFailure('invalid', 'Org transfer membership materials do not match');
+    }
     async completeOrgTransfer(params = {}, options = {}) {
         const store = options.aidStore;
         const owner = this._currentAid;
@@ -1522,20 +1804,33 @@ export class AUNClient {
         const transferId = String(params.transfer_id ?? '').trim();
         if (!store || !owner?.isPrivateKeyValid() || !orgAid || !transferId)
             throw new ValidationError('completeOrgTransfer requires aidStore, org_id, transfer_id and current accepting owner');
+        for (const field of ['previous_owner', 'new_owner']) {
+            const material = params[field];
+            if (!isJsonObject(material) || !isJsonObject(material.membership_binding) || !isJsonObject(material.terms) || field === 'previous_owner' && !isJsonObject(material.credential_template))
+                throw ownershipFailure('invalid', 'Org transfer requires both replacement membership bindings, terms and previous-owner credential');
+        }
         this._aidStore = store;
         const localStore = store._keystore;
         const tokenStore = store._tokenStore;
         const pendingKey = `org-transfer:${orgAid}:${transferId}`;
         const inputHash = crypto.createHash('sha256').update(canonicalJson(params)).digest('hex');
+        let pending = (typeof tokenStore._loadMetadataStrict === 'function' ? tokenStore._loadMetadataStrict(orgAid) : tokenStore.loadMetadata(orgAid))?.org_identity_transfer;
+        if (pending != null && !isJsonObject(pending))
+            throw ownershipFailure('persistence_unavailable', 'Org transfer checkpoint is invalid');
+        if (pending && (pending.transfer_id !== transferId || pending.owner_aid !== owner.aid || pending.input_hash !== inputHash))
+            throw ownershipFailure('conflict', 'pending Org transfer context changed');
+        if (!pending)
+            await this._verifyOrgTransferMaterials(params, owner.aid);
         let keyPair = localStore.loadPendingGroupBind(pendingKey);
         if (!keyPair) {
+            if (pending)
+                throw ownershipFailure('persistence_unavailable', 'Org transfer private key checkpoint is unavailable');
             keyPair = new CryptoProvider().generateIdentity();
             localStore.savePendingGroupBind(pendingKey, keyPair);
         }
         const target = options.serviceAid ?? `org.${orgAid.slice(orgAid.indexOf('.') + 1)}`;
         const publicKey = crypto.createPublicKey({ key: Buffer.from(keyPair.public_key_der_b64, 'base64'), format: 'der', type: 'spki' }).export({ format: 'pem', type: 'spki' }).toString();
-        let pending = tokenStore.loadMetadata(orgAid)?.org_identity_transfer;
-        if (pending && (pending.transfer_id !== transferId || pending.owner_aid !== owner.aid || pending.public_key !== publicKey || pending.input_hash !== inputHash))
+        if (pending && pending.public_key !== publicKey)
             throw ownershipFailure('conflict', 'pending Org transfer context changed');
         if (!pending) {
             const rekey = { ...params, stage: 'rekey', public_key: publicKey, curve: 'P-256' };
@@ -1546,7 +1841,7 @@ export class AUNClient {
             tokenStore.saveMetadata(orgAid, { org_identity_transfer: pending });
         }
         if (pending.phase === 'rekey') {
-            const result = await this.call('org.lifecycle.transferAccept', pending.rekey_params);
+            const result = await this.call('org.lifecycle.transferAccept', await this._resumeOrgRequest('org.lifecycle.transferAccept', pending.rekey_params, target));
             pending = { ...pending, phase: 'finalize', rekey_result: result };
             tokenStore.saveMetadata(orgAid, { org_identity_transfer: pending });
         }
@@ -1582,10 +1877,10 @@ export class AUNClient {
             pending = { ...pending, finalize_params: this.org.prepareRequest('org.lifecycle.transferAccept', final, target, owner, { orgSigner: orgIdentity }) };
             tokenStore.saveMetadata(orgAid, { org_identity_transfer: pending });
         }
-        const result = await this.call('org.lifecycle.transferAccept', pending.finalize_params);
+        const result = await this.call('org.lifecycle.transferAccept', await this._resumeOrgRequest('org.lifecycle.transferAccept', pending.finalize_params, target));
         await this._uploadOrgAgentMd(store, orgAid, pending.source_params);
-        localStore.clearPendingGroupBind(pendingKey);
         tokenStore.saveMetadata(orgAid, { org_identity_transfer: null });
+        localStore.clearPendingGroupBind(pendingKey);
         return result;
     }
     async dissolveOrg(params = {}, options = {}) {
@@ -2443,7 +2738,8 @@ export class AUNClient {
                 return;
             this._readStateCache.set(key, { method, params: query, state: { ...eventData } });
         }
-        this._dispatcher.enqueue(scope === 'group' ? 'group.read_changed' : 'message.read_changed', eventData);
+        const identity = this._ensureReadStateIdentity();
+        this._dispatcher.enqueue(scope === 'group' ? 'group.read_changed' : 'message.read_changed', eventData, () => identity === this._ensureReadStateIdentity());
     }
     async _reconcileReadStates() {
         const identity = this._ensureReadStateIdentity();
@@ -2475,7 +2771,7 @@ export class AUNClient {
             owner_aid: this._aid ?? '',
             states: [...keys].map((key) => ({ ...this._readStateCache.get(key).state })),
             errors,
-        });
+        }, () => identity === this._ensureReadStateIdentity());
     }
     async _callRawV2Rpc(method, params, pullGateKey = '') {
         const p = { ...(params ?? {}) };
@@ -2640,7 +2936,10 @@ export class AUNClient {
         if (event === 'message.received') {
             return this._handleOwnershipMessage(payload).then((handled) => {
                 if (!handled)
-                    return this._delivery.publishAppEvent(event, payload, source, deliveryContext);
+                    return this._handleCredentialRenewal(payload).then((renewed) => {
+                        if (!renewed)
+                            return this._delivery.publishAppEvent(event, payload, source, deliveryContext);
+                    });
                 return undefined;
             });
         }
@@ -3015,8 +3314,13 @@ export class AUNClient {
         try {
             if (opts.signedAt === undefined)
                 await this._auth.verifyPeerCertificate(peerGatewayUrl, certPem, aid);
-            else
+            else if (opts.agentMdRead) {
+                validateAgentMdCertificate(certPem, aid, opts.signedAt, { requireCurrentValidity: false, readCompatibility: true });
+                await this._auth._verifyAuthCertChain(peerGatewayUrl, new crypto.X509Certificate(certPem), aid, opts.signedAt);
+            }
+            else {
                 await this._auth.verifyPeerCertificate(peerGatewayUrl, certPem, aid, opts.signedAt);
+            }
         }
         catch (exc) {
             if (cachedBootstrapChain) {
@@ -3030,7 +3334,7 @@ export class AUNClient {
             validatedAt: nowSec,
             refreshAfter: nowSec + PEER_CERT_CACHE_TTL,
         };
-        const cacheKey = AUNClient._certCacheKey(aid, certFingerprint) + (opts.signedAt === undefined ? '' : `:signed:${opts.signedAt}`);
+        const cacheKey = AUNClient._certCacheKey(aid, certFingerprint) + (opts.signedAt === undefined ? '' : `:signed:${opts.signedAt}${opts.agentMdRead ? ':agentmd' : ''}`);
         this._certCache.set(cacheKey, entry);
         if (!certFingerprint && opts.signedAt === undefined) {
             const bareKey = AUNClient._certCacheKey(aid);
@@ -3040,7 +3344,7 @@ export class AUNClient {
         }
         try {
             // peer 证书只存版本目录，不覆盖 cert.pem
-            this._tokenStore.saveCert(aid, certPem, certFingerprint, { makeActive: false });
+            this._tokenStore.saveCert(aid, certPem, opts.agentMdRead && opts.signedAt !== undefined ? `sha256:${x509Cert.fingerprint256.replace(/:/g, '').toLowerCase()}` : certFingerprint, { makeActive: false });
         }
         catch (exc) {
             this._clientLog.error(`failed to write cert to keystore (aid=${aid}, fp=${certFingerprint ?? ''}): ${formatCaughtError(exc)}`, exc instanceof Error ? exc : undefined);
@@ -3055,32 +3359,47 @@ export class AUNClient {
         return certificate;
     }
     /** 获取对方证书（带缓存 + 完整 PKI 验证），跨域时自动路由到 peer 所在域。 */
-    async _fetchPeerCert(aid, certFingerprint, timeoutMs = 30_000, signedAt) {
+    async _fetchPeerCert(aid, certFingerprint, timeoutMs = 30_000, signedAt, agentMdRead = false) {
         const tStart = Date.now();
         this._clientLog.debug(`_fetchPeerCert enter: aid=${aid}, fp=${certFingerprint ?? ''}`);
         try {
-            const cacheKey = AUNClient._certCacheKey(aid, certFingerprint) + (signedAt === undefined ? '' : `:signed:${signedAt}`);
+            const cacheKey = AUNClient._certCacheKey(aid, certFingerprint) + (signedAt === undefined ? '' : `:signed:${signedAt}${agentMdRead ? ':agentmd' : ''}`);
             const cached = this._certCache.get(cacheKey);
             const now = Date.now() / 1000;
             if (cached && now < cached.refreshAfter) {
                 this._clientLog.debug(`_fetchPeerCert exit: elapsed=${Date.now() - tStart}ms aid=${aid} (cache_hit)`);
                 return cached.certPem;
             }
-            const gatewayUrl = this._gatewayUrl;
-            if (!gatewayUrl) {
-                throw new ValidationError('gateway url unavailable for e2ee cert fetch');
+            const inFlightKey = `${cacheKey}:timeout:${timeoutMs}`;
+            const pending = this._certFetchInFlight.get(inFlightKey);
+            if (pending)
+                return await pending;
+            const request = (async () => {
+                const gatewayUrl = this._gatewayUrl;
+                if (!gatewayUrl) {
+                    throw new ValidationError('gateway url unavailable for e2ee cert fetch');
+                }
+                const peerGatewayUrl = AUNClient._resolvePeerGatewayUrl(gatewayUrl, aid);
+                const certPem = await _httpGetText(AUNClient._buildCertUrl(peerGatewayUrl, aid, certFingerprint), this._configModel.verifySsl, timeoutMs);
+                const validated = await this._validateAndCachePeerCert({
+                    aid,
+                    certPem,
+                    certFingerprint,
+                    source: 'fetch',
+                    signedAt,
+                    agentMdRead,
+                });
+                this._clientLog.debug(`_fetchPeerCert exit: elapsed=${Date.now() - tStart}ms aid=${aid} (fetched)`);
+                return validated;
+            })();
+            this._certFetchInFlight.set(inFlightKey, request);
+            try {
+                return await request;
+            }
+            finally {
+                if (this._certFetchInFlight.get(inFlightKey) === request)
+                    this._certFetchInFlight.delete(inFlightKey);
             }
-            const peerGatewayUrl = AUNClient._resolvePeerGatewayUrl(gatewayUrl, aid);
-            const certPem = await _httpGetText(AUNClient._buildCertUrl(peerGatewayUrl, aid, certFingerprint), this._configModel.verifySsl, timeoutMs);
-            const validated = await this._validateAndCachePeerCert({
-                aid,
-                certPem,
-                certFingerprint,
-                source: 'fetch',
-                signedAt,
-            });
-            this._clientLog.debug(`_fetchPeerCert exit: elapsed=${Date.now() - tStart}ms aid=${aid} (fetched)`);
-            return validated;
         }
         catch (err) {
             this._clientLog.debug(`_fetchPeerCert exit (error): elapsed=${Date.now() - tStart}ms aid=${aid} err=${err instanceof Error ? err.message : String(err)}`);
@@ -3656,7 +3975,7 @@ export class AUNClient {
     }
     /** 后台 Promise 统一兜底，避免事件回调里的异步异常变成未处理拒绝。 */
     _safeAsync(promise) {
-        promise.catch((exc) => {
+        return promise.then(() => undefined).catch((exc) => {
             this._clientLog.warn(`background task exception: ${formatCaughtError(exc)}`);
         });
     }
@@ -3851,7 +4170,7 @@ export class AUNClient {
         return await this._v2E2EE.ackGroupV2(groupId, upToSeq, groupAid);
     }
     /** 解密单条 V2 pull 消息。缺 sender IK 时先入 pending，后台补齐后重试。 */
-    async _decryptV2Message(msg, allowPending = true, emitUndecryptable = true, rotateKeys = true, observeAgentMd = true, deferStatus, deferKeyFetch = false, source = 'pull') {
+    async _decryptV2Message(msg, allowPending = true, emitUndecryptable = true, rotateKeys = true, observeAgentMd = true, deferStatus, deferKeyFetch = false, source = 'pull', deferredEffects) {
         const session = this._v2Session;
         if (!session)
             return null;
@@ -3867,8 +4186,12 @@ export class AUNClient {
             return null;
         }
         const e2eeMeta = this._v2E2eeMeta(envelope);
-        if (observeAgentMd)
-            this._agentMdManager.observeEnvelope(envelope);
+        if (observeAgentMd) {
+            if (deferredEffects)
+                deferredEffects.push(() => this._agentMdManager.observeEnvelope(envelope));
+            else
+                this._agentMdManager.observeEnvelope(envelope);
+        }
         let spkId = '';
         let recipientKeySource = '';
         if (isJsonObject(envelope.recipient)) {
@@ -3947,8 +4270,12 @@ export class AUNClient {
             };
             this._attachV2EnvelopeMetadata(event, e2eeMeta);
             this._logMessageDebug('decrypt-fail', 'v2.decrypt', undecryptableEvent, event);
-            if (emitUndecryptable)
-                this._dispatcher.enqueue(undecryptableEvent, event);
+            if (emitUndecryptable) {
+                if (deferredEffects)
+                    deferredEffects.push(() => { this._dispatcher.enqueue(undecryptableEvent, event); });
+                else
+                    this._dispatcher.enqueue(undecryptableEvent, event);
+            }
             return null;
         }
         this._clientLog.debug(`V2 decrypt key lookup ok: seq=${String(msg.seq ?? '')}, group=${groupIdForKeys || '<p2p>'}, ik_len=${ikPriv.byteLength}, spk_len=${spkPriv?.byteLength ?? 0}`);
@@ -3986,8 +4313,12 @@ export class AUNClient {
             };
             this._attachV2EnvelopeMetadata(event, e2eeMeta);
             this._logMessageDebug('decrypt-fail', 'v2.decrypt', undecryptableEvent, event);
-            if (emitUndecryptable)
-                this._dispatcher.enqueue(undecryptableEvent, event);
+            if (emitUndecryptable) {
+                if (deferredEffects)
+                    deferredEffects.push(() => { this._dispatcher.enqueue(undecryptableEvent, event); });
+                else
+                    this._dispatcher.enqueue(undecryptableEvent, event);
+            }
             return null;
         }
         let plaintext;
@@ -4015,16 +4346,24 @@ export class AUNClient {
             };
             this._attachV2EnvelopeMetadata(event, e2eeMeta);
             this._logMessageDebug('decrypt-fail', 'v2.decrypt', undecryptableEvent, event);
-            if (emitUndecryptable)
-                this._dispatcher.enqueue(undecryptableEvent, event);
+            if (emitUndecryptable) {
+                if (deferredEffects)
+                    deferredEffects.push(() => { this._dispatcher.enqueue(undecryptableEvent, event); });
+                else
+                    this._dispatcher.enqueue(undecryptableEvent, event);
+            }
             return null;
         }
         if (plaintext === null) {
             this._clientLog.debug(`V2 decrypt returned null plaintext: seq=${String(msg.seq ?? '')}, group=${groupIdForKeys || '<p2p>'}`);
             return null;
         }
-        if (rotateKeys)
-            this._scheduleV2KeyRotationForMessage(msg, envelope);
+        if (rotateKeys) {
+            if (deferredEffects)
+                deferredEffects.push(() => this._scheduleV2KeyRotationForMessage(msg, envelope));
+            else
+                this._scheduleV2KeyRotationForMessage(msg, envelope);
+        }
         const e2ee = this._v2E2eeMeta(envelope);
         let result = {
             message_id: String(msg.message_id ?? ''),
@@ -4120,6 +4459,8 @@ export class AUNClient {
         if (protectedHeaders && Object.keys(protectedHeaders).length > 0) {
             meta.protected_headers = protectedHeaders;
         }
+        if (typeof envelope.need_render === 'boolean')
+            meta.need_render = envelope.need_render;
         const payloadType = String(envelope.payload_type ?? protectedHeaders?.payload_type ?? '').trim();
         if (payloadType) {
             meta.payload_type = payloadType;
@@ -4135,6 +4476,8 @@ export class AUNClient {
         return meta;
     }
     _attachV2EnvelopeMetadata(message, meta) {
+        if (typeof meta.need_render === 'boolean')
+            message.need_render = meta.need_render;
         const payloadType = typeof meta.payload_type === 'string' ? meta.payload_type.trim() : '';
         if (payloadType)
             message.payload_type = payloadType;
@@ -4492,6 +4835,7 @@ export class AUNClient {
     // ── 内部：后台任务 ────────────────────────────────────────
     /** 启动所有后台任务 */
     _startBackgroundTasks() {
+        this._startCredentialRenewal();
         // WebSocket Ping/Pong 由 Gateway 与传输层处理；SDK 不发送 RPC 心跳。
         // 短连接生命周期短，不需要 token 刷新。
         if (this._sessionOptions.connection_kind !== 'short') {
@@ -4501,6 +4845,7 @@ export class AUNClient {
     }
     /** 停止所有后台任务 */
     _stopBackgroundTasks() {
+        this._stopCredentialRenewal();
         if (this._heartbeatTimer !== null) {
             clearInterval(this._heartbeatTimer);
             this._heartbeatTimer = null;