@agentunion/fastaun 0.5.22 → 0.5.24

package/dist/client.js

@@ -48,8 +48,8 @@ import { isJsonObject, ConnectionState, STATE_TO_PUBLIC, } from './types.js';
 import { AID } from './aid.js';
 import { certFingerprint, certMatchesFingerprint, normalizeFingerprintHex, publicKeyMatchesFingerprint } from './cert-utils.js';
 import { validateAgentMdCertificate, validateAgentMdDocument } from './agent-md-schema.js';
-import { OwnershipFiles, OwnershipStorageAdapter, ownershipFailure } from './ownership-v21.js';
-import { OwnershipWorkflow } from './ownership-workflow.js';
+import { OwnershipFiles, OwnershipStorageAdapter, ownershipAid, ownershipFailure } from './ownership-v21.js';
+import { OwnershipWorkflow, OWNERSHIP_SDK_MESSAGE_TYPE, parseOwnershipMessage } from './ownership-workflow.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');
@@ -479,8 +479,6 @@ export class AUNClient {
     _currentAid = null;
     _serviceEventIdentityVersion = 0;
     _serviceEventIdentityAbort = new AbortController();
-    /** ownership 关系只在 SDK 内存中编排；服务端不保存状态机。 */
-    _ownershipRecords = new Map();
     _ownershipType = 'agent';
     _ownershipStorage = null;
     _ownershipFiles = null;
@@ -489,12 +487,15 @@ export class AUNClient {
         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({
+        return this._ownershipFiles ??= this._createOwnershipFiles((subAid, stage) => this._agentMdManager.readOwnershipFresh(subAid, stage));
+    }
+    _createOwnershipFiles(readAgentMdFresh) {
+        return new OwnershipFiles({
             currentAid: () => { if (!this._currentAid)
                 throw ownershipFailure('forbidden', 'ownership requires a loaded identity'); return this._currentAid; },
             currentType: () => this.getType(),
             now: () => Math.trunc(Date.now() / 1000),
-            readAgentMdFresh: (subAid) => this._agentMdManager.readOwnershipFresh(subAid),
+            readAgentMdFresh,
             submitAgentMdRaw: (subAid, raw, condition, assertActive, stage) => this._agentMdManager.submitOwnershipRaw(subAid, raw, condition, assertActive, stage),
             readOwnerMd: (ownerAid, subAid) => this._getOwnershipStorage().readOwnerMd(ownerAid, subAid),
             writeOwnerMd: (ownerAid, subAid, raw, original, assertActive) => this._getOwnershipStorage().writeOwnerMd(ownerAid, subAid, raw, original, assertActive),
@@ -504,59 +505,65 @@ export class AUNClient {
     }
     _getOwnershipWorkflow() {
         return this._ownershipWorkflow ??= new OwnershipWorkflow({
-            currentAid: () => this._aid, store: this._tokenStore, files: this._getOwnershipFiles(),
-            currentType: () => this.getType(),
+            currentAid: () => this._aid, files: this._getOwnershipFiles(),
+            currentType: () => this.getType(), assertCurrent: () => this._ownershipOperationGuard?.(),
+            recoverRequest: (operationId) => this._recoverOwnershipRequest(operationId),
             send: (to, payload, messageId) => this.call('message.send', { to, encrypt: true, message_id: messageId, payload: payload }),
             emit: (event, payload) => this._dispatcher.enqueue(event, payload),
         });
     }
-    _persistOwnershipRecords() {
-        const aid = String(this._aid ?? '').trim();
-        if (!aid)
-            return;
-        const metadata = this._tokenStore.loadMetadata?.(aid) ?? {};
-        const existing = metadata.ownership_records;
-        const records = existing && typeof existing === 'object' && !Array.isArray(existing)
-            ? { ...existing } : {};
-        for (const [key, record] of this._ownershipRecords) {
-            if (![record.subject_aid, record.owner_aid].some((value) => String(value ?? '').trim().toLowerCase() === aid.toLowerCase()))
-                continue;
-            records[key] = Object.fromEntries(Object.entries(record).filter(([name]) => !['subject_identity', 'escrow_password', 'escrow_download_url'].includes(name)));
+    async _recoverOwnershipRequest(operationId) {
+        const identity = this._aid, version = this._serviceEventIdentityVersion;
+        const current = () => { if (this._aid !== identity || this._serviceEventIdentityVersion !== version)
+            throw ownershipFailure('conflict', 'ownership request identity changed'); };
+        const catalog = await this.call('message.peers', { filter: 'all', limit: 200 });
+        current();
+        for (const peer of Array.isArray(catalog.peers) ? catalog.peers.slice(0, 200) : []) {
+            const sender = String(peer.sender_aid ?? '');
+            const history = await this.call('message.history', { sender_aid: sender, before_seq: Number.MAX_SAFE_INTEGER, limit: 200 });
+            current();
+            for (const row of Array.isArray(history.messages) ? history.messages : []) {
+                const envelope = row, content = envelope.payload ?? envelope;
+                const raw = decryptedOwnershipJsonText(content) ?? content;
+                let value = raw;
+                if (typeof raw === 'string') {
+                    try {
+                        value = JSON.parse(raw);
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                if (!isJsonObject(value) || value.type !== OWNERSHIP_SDK_MESSAGE_TYPE || value.operation_id !== operationId || !['bind.request', 'transfer.request'].includes(String(value.action)))
+                    continue;
+                const authenticated = String(envelope.from_aid ?? envelope.from ?? envelope.sender_aid ?? '');
+                if (authenticated !== sender)
+                    throw ownershipFailure('forbidden', 'ownership history sender changed');
+                return { from: authenticated, payload: parseOwnershipMessage(raw, { authenticated_from_aid: authenticated, local_aid: identity }) };
+            }
         }
-        this._tokenStore.saveMetadata?.(aid, { ownership_records: records });
+        return null;
     }
-    _restoreOwnershipRecords() {
+    _restoreIdentityType() {
         const aid = String(this._aid ?? '').trim();
         if (!aid)
             return;
         const metadata = this._tokenStore.loadMetadata?.(aid);
-        const intent = metadata?.registration_intent;
-        if (intent?.type)
-            this._ownershipType = String(intent.type);
-        const records = metadata?.ownership_records;
-        if (!records || typeof records !== 'object' || Array.isArray(records))
-            return;
-        for (const [key, value] of Object.entries(records)) {
-            if (!value || typeof value !== 'object' || Array.isArray(value))
-                continue;
-            const record = value;
-            this._ownershipRecords.set(key, record);
-            if (String(record.subject_aid ?? '').toLowerCase() === aid.toLowerCase())
-                this._ownershipType = String(record.type ?? this._ownershipType);
-        }
-    }
-    async _resumeOwnershipAfterConnect() {
-        await this._checkIdentityAdmissionAfterConnect();
-        await this._resumeRegistrationIntent();
-        await this._resumeOwnership();
+        const legacy = metadata?.registration_intent;
+        if (metadata?.identity_type ?? legacy?.type)
+            this._ownershipType = String(metadata?.identity_type ?? legacy?.type);
     }
+    _ownershipOperation = false;
+    _ownershipOperationGuard;
     _credentialRenewal;
     _credentialRenewalTimer = null;
     _credentialRenewalAbort = null;
     _credentialRenewalScan = Promise.resolve();
+    _nextCredentialRevocationSyncAt = 0;
     _getCredentialRenewal() {
         return this._credentialRenewal ??= new CredentialRenewal({
             currentAid: () => this._aid ?? '',
+            queryContext: () => JSON.stringify([this._serviceEventIdentityVersion, this._gatewayUrl, this._transport?._connectionGeneration, this._transport?._workerGeneration]),
             atomicCheckpointSave: () => this._tokenStore instanceof LocalTokenStore,
             load: (aid) => (this._tokenStore._loadMetadataStrict?.(aid) ?? this._tokenStore.loadMetadata?.(aid))?.credential_renewals_v1 ?? {},
             ...(typeof this._tokenStore._loadMetadataStrict === 'function' ? {
@@ -630,6 +637,7 @@ export class AUNClient {
             if (aid === this._aid && this._identity) {
                 this._identity.cert = identity.certPem;
                 this._currentAid = identity;
+                this._auth.setIdentity(this._identity);
             }
         }
         return identity;
@@ -665,14 +673,14 @@ export class AUNClient {
         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 };
-        let nextRevocationSync = Date.now() + 3_600_000;
+        this._nextCredentialRevocationSyncAt ||= Date.now() + 3_600_000;
         const scan = async () => {
             const task = this._credentialRenewalScan.then(async () => {
                 if (!current())
                     return;
-                const syncRevocations = Date.now() >= nextRevocationSync;
+                const syncRevocations = Date.now() >= this._nextCredentialRevocationSyncAt;
                 if (syncRevocations)
-                    nextRevocationSync = Date.now() + 3_600_000;
+                    this._nextCredentialRevocationSyncAt = Date.now() + 3_600_000;
                 await this._resumeCredentialRenewalAfterConnect(guard, syncRevocations);
             });
             this._credentialRenewalScan = task.catch(() => { });
@@ -710,6 +718,10 @@ export class AUNClient {
         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');
+        const eventName = event.replace(/^event\//, '');
+        if (eventName.startsWith('org.') || ['credential.revoked', 'credential.revocationList'].includes(eventName)) {
+            this._getCredentialRenewal().invalidateQueries?.();
+        }
         if (['credential.revoked', 'credential.revocationList'].includes(event.replace(/^event\//, ''))) {
             await this._getCredentialRenewal()._receiveRevocations(payload, { current, signal });
         }
@@ -740,18 +752,6 @@ export class AUNClient {
         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())))
-            return;
-        if (intent?.protocol !== '2.1' || intent.pending !== true)
-            return;
-        await this._getOwnershipWorkflow().resumeRegistration(String(intent.owner), String(intent.operation_id));
-        this._tokenStore.saveMetadata?.(this._aid, { registration_intent: { ...intent, pending: false } });
-    }
-    async _resumeOwnership() {
-        await this._getOwnershipWorkflow().resume();
-    }
     /** 实例级 protected_headers */
     _instanceProtectedHeaders = null;
     /** 重连退避时间戳（ms） */
@@ -947,7 +947,7 @@ export class AUNClient {
             net: dnsNet,
         });
         this._aid = initAid;
-        this._restoreOwnershipRecords();
+        this._restoreIdentityType();
         this._agentMdManager = createAgentMdManagerForRuntime({
             config: () => this._configModel,
             logger: () => this._logger.for('aun_core.agent_md'),
@@ -1128,9 +1128,6 @@ export class AUNClient {
     get currentAid() {
         return this._currentAid;
     }
-    _ownershipKey(subjectAid, ownerAid) {
-        return `${String(subjectAid ?? '').trim().toLowerCase()}|${String(ownerAid ?? '').trim().toLowerCase()}`;
-    }
     getType() {
         return String(this._ownershipType || 'agent').trim() || 'agent';
     }
@@ -1138,45 +1135,12 @@ export class AUNClient {
         return this.getType();
     }
     getOwner() {
-        const aid = String(this._aid ?? '').trim().toLowerCase();
-        let best = null;
-        let bestActive = false;
-        for (const record of this._ownershipRecords.values()) {
-            if (String(record.subject_aid ?? '').trim().toLowerCase() === aid) {
-                if (String(record.status ?? '').trim().toLowerCase() === 'released')
-                    continue;
-                const owner = String(record.owner_aid ?? '').trim();
-                if (!owner)
-                    continue;
-                const active = String(record.status ?? '').trim().toLowerCase() === 'active';
-                if (!best || active && !bestActive) {
-                    best = owner;
-                    bestActive = active;
-                }
-            }
-        }
-        return best;
+        return null;
     }
     get_owner() {
         return this.getOwner();
     }
     getOwnershipStatus() {
-        const aid = String(this._aid ?? '').trim().toLowerCase();
-        let best = null;
-        let bestActive = false;
-        for (const record of this._ownershipRecords.values()) {
-            const subject = String(record.subject_aid ?? '').trim().toLowerCase();
-            const owner = String(record.owner_aid ?? '').trim().toLowerCase();
-            if (aid !== subject && aid !== owner)
-                continue;
-            const active = String(record.status ?? '').trim().toLowerCase() === 'active';
-            if (!best || active && !bestActive) {
-                best = record;
-                bestActive = active;
-            }
-        }
-        if (best)
-            return Object.fromEntries(Object.entries(best).filter(([key]) => key !== 'subject_identity' && key !== 'escrow_password' && key !== 'escrow_download_url'));
         return { subject_aid: this._aid ?? '', owner_aid: null, status: 'legacy_unbound', type: this.getType() };
     }
     get_ownership_status() {
@@ -1184,10 +1148,61 @@ 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 bindLocalSubaid(subClient) { return this._localOwnershipOperation(subClient); }
+    async transferLocalSubaid(subClient, newOwnerClient) { return this._localOwnershipOperation(subClient, newOwnerClient); }
+    _createOwnershipOperationClient(slotId) {
+        const aid = this._currentAid;
+        const client = new AUNClient(AID._create({ aid: aid.aid, aunPath: aid.aunPath, certPem: aid.certPem, privateKeyPem: aid.privateKeyPem,
+            certValid: aid.isCertValid(), privateKeyValid: aid.isPrivateKeyValid(), deviceId: this._deviceId, slotId,
+            verifySsl: aid.verifySsl, rootCaPath: aid.rootCaPath, debug: aid.debug, aidStore: aid._aidStore }));
+        client._ownershipOperation = true;
+        client._ownershipType = this.getType();
+        return client;
+    }
+    async _localOwnershipOperation(sub, next) {
+        const sources = [this, sub, ...(next ? [next] : [])];
+        if (sources.some((source) => !(source instanceof AUNClient) || !source._currentAid?.isPrivateKeyValid() || !source._currentAid.isCertValid() || !source._currentAid.privateKeyPem || source._currentAid.aid !== source._aid || source.getType() !== 'agent') || new Set(sources.map((source) => source._aid)).size !== sources.length)
+            throw ownershipFailure('forbidden', 'local ownership requires distinct agent clients with private identities');
+        const identities = sources.map((source) => [source._aid, source._currentAid, source._serviceEventIdentityVersion]);
+        const guard = () => { if (sources.some((source, index) => source._aid !== identities[index][0] || source._currentAid !== identities[index][1] || source._serviceEventIdentityVersion !== identities[index][2]))
+            throw ownershipFailure('conflict', 'local ownership source identity changed'); };
+        for (const source of sources) {
+            guard();
+            const document = await source._agentMdManager.readAgentMdFresh(source._aid);
+            guard();
+            if (!document.exists)
+                throw ownershipFailure('forbidden', 'local ownership requires a published agent document');
+            const verified = await source._getOwnershipFiles().verifyFile(document.content, 'agent', source._aid);
+            guard();
+            if (verified.frontmatter.type !== 'agent')
+                throw ownershipFailure('forbidden', 'local ownership requires verified agent identities');
+        }
+        const slot = `ownership-${crypto.randomUUID()}`, clients = [];
+        try {
+            for (const source of sources) {
+                const client = source._createOwnershipOperationClient(slot);
+                client._ownershipOperationGuard = guard;
+                clients.push(client);
+            }
+            for (const client of clients) {
+                guard();
+                await client.connect({ connection_kind: 'short', background_sync: false, auto_reconnect: false });
+                guard();
+            }
+            return next ? await clients[0]._getOwnershipWorkflow().transferLocalSubaid(clients[1]._getOwnershipWorkflow(), clients[2]._getOwnershipWorkflow()) : await clients[0]._getOwnershipWorkflow().bindLocalSubaid(clients[1]._getOwnershipWorkflow());
+        }
+        finally {
+            await Promise.all(clients.map((client) => client.close()));
+        }
+    }
     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); }
+    async checkOwnershipConsensus(subAid) {
+        return this._createOwnershipFiles((aid) => this._agentMdManager._readOwnershipQuery(aid)).checkConsensus(ownershipAid(subAid ?? this._aid, 'sub_aid'));
+    }
+    async _checkOwnershipConsensusFresh(subAid) {
+        return this._getOwnershipWorkflow().checkOwnershipConsensus(subAid);
+    }
     async bindAid(subjectAid, options = {}) {
         throw ownershipFailure('unsupported_protocol', 'legacy bindAid is unsupported; use bindSubaid');
     }
@@ -1209,7 +1224,28 @@ export class AUNClient {
             return false;
         const envelope = message;
         const content = 'payload' in envelope ? envelope.payload : message;
-        return this._getOwnershipWorkflow().receive(String(envelope.from_aid ?? ''), decryptedOwnershipJsonText(content) ?? content);
+        const raw = decryptedOwnershipJsonText(content) ?? content, sender = String(envelope.from_aid ?? '');
+        let value = raw;
+        if (typeof value === 'string') {
+            try {
+                value = JSON.parse(value);
+            }
+            catch {
+                return false;
+            }
+        }
+        if (value && typeof value === 'object' && !Array.isArray(value) && value.type === OWNERSHIP_SDK_MESSAGE_TYPE) {
+            const control = value, request = control.action === 'bind.request' || control.action === 'transfer.request';
+            try {
+                parseOwnershipMessage(raw, { authenticated_from_aid: sender, local_aid: this._aid, ...(request ? {} : { task: { ...control, initiator_aid: this._aid } }) });
+            }
+            catch (error) {
+                if (error instanceof ValidationError && !error.retryable || error instanceof StateError && !error.retryable && ['invalid', 'forbidden'].includes(error.stringCode))
+                    return true;
+                throw error;
+            }
+        }
+        return this._getOwnershipWorkflow().receive(sender, raw);
     }
     get hasIdentity() {
         return this._currentAid !== null && this.state !== ConnectionState.CLOSED;
@@ -1394,14 +1430,16 @@ export class AUNClient {
         this._identityRuntime.loadIdentity(aid);
         this._stopCredentialRenewal();
         this._serviceEventIdentityVersion++;
+        this._auth.invalidateStrictPkiCache();
+        this._certCache.clear();
+        this._certFetchInFlight.clear();
         this._serviceEventIdentityAbort.abort();
         this._serviceEventIdentityAbort = new AbortController();
         this._ensureReadStateIdentity();
         if (previousAid !== this._aid) {
-            this._ownershipRecords.clear();
             this._ownershipType = 'agent';
         }
-        this._restoreOwnershipRecords();
+        this._restoreIdentityType();
     }
     setProtectedHeaders(headers) {
         if (!headers) {
@@ -3339,6 +3377,8 @@ export class AUNClient {
                 this._clientLog.debug(`bootstrap CA chain cache skipped: peer=${aid}, source=${opts.source ?? 'unknown'}, err=${formatCaughtError(exc)}`);
             }
         }
+        const auth = this._auth;
+        const pkiEpoch = auth._strictPkiEpoch;
         try {
             if (opts.signedAt === undefined)
                 await this._auth.verifyPeerCertificate(peerGatewayUrl, certPem, aid);
@@ -3356,20 +3396,21 @@ export class AUNClient {
             }
             throw new ValidationError(`peer cert verification failed for ${aid}: ${exc instanceof Error ? exc.message : String(exc)}`);
         }
+        if (auth !== this._auth || pkiEpoch !== auth._strictPkiEpoch)
+            throw new ValidationError('peer certificate validation context changed');
         const nowSec = Date.now() / 1000;
         const entry = {
             certPem,
             validatedAt: nowSec,
-            refreshAfter: nowSec + PEER_CERT_CACHE_TTL,
+            refreshAfter: Math.min(nowSec + PEER_CERT_CACHE_TTL, Date.parse(x509Cert.validTo) / 1000, auth._gatewayChainCache.get(`${peerGatewayUrl}:${aid}`)?.expiresAt / 1000 || Infinity),
+            auth,
+            pkiEpoch,
         };
-        const cacheKey = AUNClient._certCacheKey(aid, certFingerprint) + (opts.signedAt === undefined ? '' : `:signed:${opts.signedAt}${opts.agentMdRead ? ':agentmd' : ''}`);
+        const scope = opts.signedAt === undefined ? '' : `:historical${opts.agentMdRead ? ':agentmd' : ''}`;
+        const actualFp = `sha256:${x509Cert.fingerprint256.replace(/:/g, '').toLowerCase()}`;
+        const cacheKey = AUNClient._certCacheKey(aid, actualFp) + scope;
         this._certCache.set(cacheKey, entry);
-        if (!certFingerprint && opts.signedAt === undefined) {
-            const bareKey = AUNClient._certCacheKey(aid);
-            this._certCache.set(bareKey, entry);
-            const actualFp = `sha256:${x509Cert.fingerprint256.replace(/:/g, '').toLowerCase()}`;
-            this._certCache.set(AUNClient._certCacheKey(aid, actualFp), entry);
-        }
+        this._certCache.set(AUNClient._certCacheKey(aid, certFingerprint) + scope, entry);
         try {
             // peer 证书只存版本目录，不覆盖 cert.pem
             this._tokenStore.saveCert(aid, certPem, opts.agentMdRead && opts.signedAt !== undefined ? `sha256:${x509Cert.fingerprint256.replace(/:/g, '').toLowerCase()}` : certFingerprint, { makeActive: false });
@@ -3391,14 +3432,46 @@ export class AUNClient {
         const tStart = Date.now();
         this._clientLog.debug(`_fetchPeerCert enter: aid=${aid}, fp=${certFingerprint ?? ''}`);
         try {
-            const cacheKey = AUNClient._certCacheKey(aid, certFingerprint) + (signedAt === undefined ? '' : `:signed:${signedAt}${agentMdRead ? ':agentmd' : ''}`);
+            const cacheKey = AUNClient._certCacheKey(aid, certFingerprint) + (signedAt === undefined ? '' : `:historical${agentMdRead ? ':agentmd' : ''}`);
             const cached = this._certCache.get(cacheKey);
             const now = Date.now() / 1000;
-            if (cached && now < cached.refreshAfter) {
+            const auth = this._auth, pkiEpoch = auth._strictPkiEpoch;
+            if (cached && cached.auth === auth && cached.pkiEpoch === pkiEpoch && now < cached.refreshAfter) {
+                if (signedAt === undefined) {
+                    const statusKey = `${cacheKey}:status:${pkiEpoch}`;
+                    let pending = this._certFetchInFlight.get(statusKey);
+                    if (!pending) {
+                        pending = (async () => {
+                            await auth.verifyPeerCertificate(AUNClient._resolvePeerGatewayUrl(this._gatewayUrl, aid), cached.certPem, aid);
+                            if (auth !== this._auth || pkiEpoch !== auth._strictPkiEpoch)
+                                throw new ValidationError('peer certificate status context changed');
+                            return cached.certPem;
+                        })();
+                        this._certFetchInFlight.set(statusKey, pending);
+                    }
+                    try {
+                        await pending;
+                    }
+                    finally {
+                        if (this._certFetchInFlight.get(statusKey) === pending)
+                            this._certFetchInFlight.delete(statusKey);
+                    }
+                }
+                else {
+                    const peerGatewayUrl = AUNClient._resolvePeerGatewayUrl(this._gatewayUrl, aid);
+                    if (agentMdRead) {
+                        validateAgentMdCertificate(cached.certPem, aid, signedAt, { requireCurrentValidity: false, readCompatibility: true });
+                        await auth._verifyAuthCertChain(peerGatewayUrl, new crypto.X509Certificate(cached.certPem), aid, signedAt);
+                    }
+                    else
+                        await auth.verifyPeerCertificate(peerGatewayUrl, cached.certPem, aid, signedAt);
+                    if (auth !== this._auth || pkiEpoch !== auth._strictPkiEpoch)
+                        throw new ValidationError('peer certificate validation context changed');
+                }
                 this._clientLog.debug(`_fetchPeerCert exit: elapsed=${Date.now() - tStart}ms aid=${aid} (cache_hit)`);
                 return cached.certPem;
             }
-            const inFlightKey = `${cacheKey}:timeout:${timeoutMs}`;
+            const inFlightKey = `${cacheKey}:signed:${signedAt ?? 'current'}:timeout:${timeoutMs}:pki:${pkiEpoch}`;
             const pending = this._certFetchInFlight.get(inFlightKey);
             if (pending)
                 return await pending;
@@ -3409,6 +3482,8 @@ export class AUNClient {
                 }
                 const peerGatewayUrl = AUNClient._resolvePeerGatewayUrl(gatewayUrl, aid);
                 const certPem = await _httpGetText(AUNClient._buildCertUrl(peerGatewayUrl, aid, certFingerprint), this._configModel.verifySsl, timeoutMs);
+                if (auth !== this._auth || pkiEpoch !== auth._strictPkiEpoch)
+                    throw new ValidationError('peer certificate fetch context changed');
                 const validated = await this._validateAndCachePeerCert({
                     aid,
                     certPem,
@@ -3829,7 +3904,9 @@ export class AUNClient {
     }
     /** 构建证书下载 URL */
     static _certCacheKey(aid, certFingerprint) {
-        const normalized = String(certFingerprint ?? '').trim().toLowerCase();
+        const raw = String(certFingerprint ?? '').trim().toLowerCase();
+        const hex = normalizeFingerprintHex(raw);
+        const normalized = hex ? `sha256:${hex}` : raw;
         return normalized ? `${aid}#${normalized}` : aid;
     }
     static _buildCertUrl(gatewayUrl, aid, certFingerprint) {
@@ -3984,7 +4061,8 @@ export class AUNClient {
                     this._clientLog.warn(`schedule post-connect P2P gap fill failed: ${formatCaughtError(exc)}`);
                 });
             }
-            this._safeAsync(this._resumeOwnershipAfterConnect());
+            if (!this._ownershipOperation)
+                this._safeAsync(this._checkIdentityAdmissionAfterConnect());
             this._clientLog.debug(`_connectOnce exit: elapsed=${Date.now() - tStart}ms gateway=${gatewayUrl}, aid=${this._aid ?? ''}`);
         }
         catch (err) {
@@ -4874,6 +4952,9 @@ export class AUNClient {
     /** 停止所有后台任务 */
     _stopBackgroundTasks() {
         this._stopCredentialRenewal();
+        this._auth.invalidateStrictPkiCache();
+        this._certCache.clear();
+        this._certFetchInFlight.clear();
         if (this._heartbeatTimer !== null) {
             clearInterval(this._heartbeatTimer);
             this._heartbeatTimer = null;