@agentunion/fastaun 0.5.29 → 0.5.31

package/dist/client.js

@@ -17,6 +17,7 @@ import { URL } from 'node:url';
 import { configFromMap, getDeviceId, normalizeSlotId } from './config.js';
 import { CryptoProvider } from './crypto.js';
 import { GatewayDiscovery } from './discovery.js';
+import { VERSION } from './version.js';
 import { DnsResilientNet } from './net.js';
 import { AUNError, AuthError, ConnectionError, E2EEError, NotFoundError, PermissionError, StateError, TimeoutError, ValidationError, } from './errors.js';
 import { EventDispatcher } from './events.js';
@@ -26,7 +27,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 } from './agent-md.js';
+import { AgentMdManager, buildDefaultAgentMd, updateOwnershipAgentMd } from './agent-md.js';
 import { AgentMdChangeCoordinator } from './agent-md-changes.js';
 import { GroupIndexMetaCache } from './group-index.js';
 import { SeqTracker } from './seq-tracker.js';
@@ -50,8 +51,8 @@ import { decryptedOwnershipJsonText, decryptedMessagePayloadBytes } from './v2/e
 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, ownershipAid, ownershipFailure, ownershipSha256, parseOwnershipFile } from './ownership-v21.js';
+import { validateAgentMdCertificate, validateAgentMdDocument, validateAgentMdReadDocument } from './agent-md-schema.js';
+import { OwnershipFiles, OwnershipStorageAdapter, ownershipAid, ownershipFailure, ownershipSha256, parseOwnershipFile, signOwnershipFile } 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';
 import { SemanticProtocolError } from './semantic-protocol.js';
@@ -491,7 +492,8 @@ export class AUNClient {
     _ownershipWorkflow = null;
     _ownershipConsensusCache = new Map();
     _getOwnershipStorage() {
-        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) });
+        return this._ownershipStorage ??= new OwnershipStorageAdapter({ currentAid: () => this._aid, call: (method, params, guard) => guard ? this._rpcPipeline.call(method, params, guard) : this.call(method, params), httpPut: async (url, data, headers, guard) => { const response = await this._riskFetch(url, { method: 'PUT', body: new Uint8Array(data).buffer, headers }, (target, init) => { guard?.(); return fetch(target, init); }); if (!response.ok)
+                throw ownershipFailure('unavailable', `Storage owner.md HTTP PUT failed: ${response.status}`, true); } });
     }
     _getOwnershipFiles() {
         return this._ownershipFiles ??= this._createOwnershipFiles((subAid, stage) => this._agentMdManager.readOwnershipFresh(subAid, stage));
@@ -906,6 +908,8 @@ export class AUNClient {
     _agentMdManager;
     _aidStore;
     _groupIdentityOperations = new Map();
+    _entityOwnershipConnection = 0;
+    _entityOwnershipChecks = new Map();
     _groupIndexMetaCache = new GroupIndexMetaCache();
     /** 消息序列号跟踪器（群消息 + P2P 空洞检测） */
     _p2pPeerPullEnabled = true;
@@ -990,6 +994,8 @@ export class AUNClient {
     _reconnectTask = null;
     _reconnectEventDispatchDepth = 0;
     _gatewayConnectionId = '';
+    _gatewayRuntimeIdentity = null;
+    _gatewayReleaseRevision = 0;
     _negotiatedCapabilities = {};
     _riskNegotiated = false;
     _riskRestoredAid = '';
@@ -1324,12 +1330,12 @@ export class AUNClient {
     }
     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');
+        if (sources.some((source, index) => !(source instanceof AUNClient) || !source._currentAid?.isPrivateKeyValid() || !source._currentAid.isCertValid() || !source._currentAid.privateKeyPem || source._currentAid.aid !== source._aid || (index === 1 ? source.getType() !== 'agent' : !['human', 'agent'].includes(source.getType()))) || new Set(sources.map((source) => source._aid)).size !== sources.length)
+            throw ownershipFailure('forbidden', 'local ownership requires a distinct agent subaid and human or agent owners 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) {
+        for (const [index, source] of sources.entries()) {
             guard();
             const document = await source._agentMdManager.readAgentMdFresh(source._aid);
             guard();
@@ -1337,8 +1343,8 @@ export class AUNClient {
                 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');
+            if ((index === 1 ? verified.frontmatter.type !== 'agent' : typeof verified.frontmatter.type !== 'string' || !['human', 'agent'].includes(verified.frontmatter.type)))
+                throw ownershipFailure('forbidden', 'local ownership requires an agent subaid and human or agent owners');
         }
         const slot = `ownership-${crypto.randomUUID()}`, clients = [];
         try {
@@ -1899,20 +1905,231 @@ export class AUNClient {
      * 自动处理内部方法限制、E2EE 加解密、客户端签名等。
      */
     async call(method, params) {
+        const assertCurrent = ['group.transfer_owner', 'org.lifecycle.transfer', 'group.dissolve', 'org.lifecycle.dissolve'].includes(method) ? this._entityOwnershipGuard() : undefined;
+        const recoverOwnership = ['group.transfer_owner', 'org.lifecycle.transfer', 'group.dissolve', 'org.lifecycle.dissolve'].includes(method) ? await this._prepareEntityOwnershipLifecycle(method, params ?? {}) : undefined;
+        await this._checkEntityOwnershipOnAccess(method, params ?? {});
         const readIdentity = ['message.read', 'message.read_state', 'group.read', 'group.read_state'].includes(method)
             ? this._ensureReadStateIdentity() : null;
         try {
-            const result = await this._rpcPipeline.call(method, params);
+            const result = await this._rpcPipeline.call(method, params, assertCurrent);
             await this._safeAsync(this._getCredentialRenewal().observe(method, params ?? {}, result));
             if (readIdentity !== null && readIdentity === this._ensureReadStateIdentity())
                 this._observeReadStateResult(method, result, params ?? {});
             return result;
         }
         catch (err) {
+            if (recoverOwnership) {
+                try {
+                    await recoverOwnership(err);
+                }
+                catch { }
+            }
             await this._maybeHandleHalfOpenRpcFailure(err);
             throw err;
         }
     }
+    _entityOwnershipGuard() {
+        const owner = this._currentAid, identity = `${this._aid}:${this._serviceEventIdentityVersion}:${this._entityOwnershipConnection}`;
+        return () => { if (`${this._aid}:${this._serviceEventIdentityVersion}:${this._entityOwnershipConnection}` !== identity || this._currentAid !== owner || this._closing || this._disconnecting)
+            throw ownershipFailure('conflict', 'entity ownership connection changed'); };
+    }
+    async _prepareEntityOwnershipLifecycle(method, params) {
+        const type = method.startsWith('group.') ? 'group' : 'org';
+        const aid = String(params.group_aid ?? params.group_id ?? params.org_id ?? '').trim().toLowerCase();
+        if (!aid)
+            return;
+        const owner = this._currentAid;
+        const identity = `${this._aid}:${this._serviceEventIdentityVersion}:${this._entityOwnershipConnection}`;
+        const assertCurrent = () => { if (`${this._aid}:${this._serviceEventIdentityVersion}:${this._entityOwnershipConnection}` !== identity || this._currentAid !== owner)
+            throw ownershipFailure('conflict', 'entity lifecycle identity changed'); };
+        const response = await this._entityLifecycle(aid, type);
+        assertCurrent();
+        const result = response;
+        const entity = (isJsonObject(result.group) ? result.group : isJsonObject(result.organization) ? result.organization : result);
+        if (entity.owner_aid !== this._aid || entity.status !== 'active')
+            return;
+        const target = String(entity.group_aid ?? entity.org_id ?? aid);
+        if (!owner?.isPrivateKeyValid())
+            throw ownershipFailure('unavailable', 'entity lifecycle requires its owner signing identity', true);
+        const observed = await this._agentMdManager.readAgentMdFresh(target);
+        const meta = observed.exists ? validateAgentMdReadDocument(observed.content, { expectedAid: target }).frontmatter : {};
+        if (!meta.ownership)
+            await this._completeEntityOwnership(target, type, undefined, assertCurrent);
+        const storage = this._getOwnershipStorage(), original = await storage.readOwnerMd(owner.aid, target);
+        if (!original.exists)
+            throw ownershipFailure('conflict', 'entity lifecycle owner declaration is missing');
+        const declaration = await this._getOwnershipFiles().verifyFile(original.content, 'owner', target, owner.aid);
+        const transfer = method.endsWith('transfer') || method.endsWith('transfer_owner');
+        const newOwner = String(params.target_member_aid ?? params.new_owner_aid ?? params.new_owner ?? params.aid ?? '').trim().toLowerCase();
+        const action = transfer ? 'transfer_owner' : 'release';
+        if (declaration.action === action && (!transfer || declaration.transfer?.new_owner_aid === newOwner && declaration.transfer.expires_at >= Date.now() / 1000))
+            return;
+        if (declaration.action !== 'declare' || !declaration.statement)
+            throw ownershipFailure('conflict', 'entity lifecycle ownership action changed');
+        const ownership = { statement: declaration.statement, action, ...(transfer ? { transfer: { new_owner_aid: ownershipAid(newOwner, 'new_owner_aid'), target_relation_version: declaration.statement.relation_version + 1, expires_at: Number(params.expires_at ?? Math.floor(Date.now() / 1000) + 3600) } } : {}) };
+        const raw = signOwnershipFile(owner, `---\nowner_aid: ${owner.aid}\nsub_aid: ${target}\nownership: ${JSON.stringify(ownership)}\n---\n`, 'owner');
+        await storage.writeOwnerMd(owner.aid, target, raw, original, assertCurrent);
+        return async (error) => {
+            if (!(error instanceof AUNError) || error instanceof TimeoutError || error instanceof ConnectionError || error.retryable || isJsonObject(error.data) && error.data.committed === true || ![-32602, 4000, 4030, 403].includes(error.code) && !['INVALID_ARGUMENT', 'ROLE_ACCESS_DENIED', 'MEMBER_NOT_FOUND', 'permission_denied', 'member_banned', 'member_blocked'].includes(error.stringCode))
+                return;
+            assertCurrent();
+            const response = await this._entityLifecycle(target, type);
+            const data = response, current = (isJsonObject(data.group) ? data.group : isJsonObject(data.organization) ? data.organization : data);
+            if (current.owner_aid !== owner.aid || current.status !== 'active')
+                return;
+            const observed = await storage.readOwnerMd(owner.aid, target);
+            if (!observed.exists || observed.content !== raw)
+                return;
+            assertCurrent();
+            await storage.writeOwnerMd(owner.aid, target, original.content, observed, assertCurrent);
+        };
+    }
+    async _checkEntityOwnershipOnAccess(method, params) {
+        const type = method.startsWith('group.') ? 'group' : method.startsWith('org.') ? 'org' : '';
+        const rawTarget = String(params.group_aid ?? params.group_id ?? params.org_id ?? '').trim().toLowerCase();
+        const target = type === 'group' ? normalizeGroupId(rawTarget, { localIssuer: this._aid?.split('.').slice(1).join('.') }) : rawTarget;
+        if (!type || !target || ['group.create', 'group.bind_group_aid', 'group.renew_group_aid', 'group.complete_transfer', 'group.transfer_owner', 'group.dissolve', 'org.lifecycle.create', 'org.lifecycle.transfer', 'org.lifecycle.transferAccept', 'org.lifecycle.dissolve'].includes(method))
+            return;
+        const identity = `${this._aid}:${this._serviceEventIdentityVersion}:${this._entityOwnershipConnection}`;
+        const key = `${identity}:${target}`;
+        let task = this._entityOwnershipChecks.get(key);
+        if (!task) {
+            task = (async () => {
+                const store = this._aidStore;
+                if (!store)
+                    return false;
+                if (!store.load(target).ok) {
+                    let pending = null;
+                    const keystore = store._keystore;
+                    if (type === 'group')
+                        for (const id of new Set([target, String(params.group_id ?? target)])) {
+                            pending = keystore?.loadPendingGroupBind?.(`bind:${id}`) ?? keystore?.loadPendingGroupBind?.(id);
+                            if (pending?.private_key_pem && pending.public_key_der_b64)
+                                break;
+                        }
+                    if (!pending?.private_key_pem || !pending.public_key_der_b64)
+                        return false;
+                }
+                const result = await this._entityLifecycle(target, type);
+                const data = result;
+                const entity = (isJsonObject(data.group) ? data.group : isJsonObject(data.organization) ? data.organization : data);
+                if (`${this._aid}:${this._serviceEventIdentityVersion}:${this._entityOwnershipConnection}` !== identity || entity.owner_aid !== this._aid || entity.status !== 'active')
+                    return false;
+                const aid = String(entity.group_aid ?? entity.org_id ?? target).toLowerCase();
+                if (aid !== target) {
+                    const existing = this._entityOwnershipChecks.get(`${identity}:${aid}`);
+                    if (existing && existing !== task)
+                        return await existing;
+                    this._entityOwnershipChecks.set(`${identity}:${aid}`, task);
+                }
+                const consensus = await this.checkOwnershipConsensus(aid, true);
+                if (consensus.status === 'consensus' && consensus.owner_aid === this._aid)
+                    return true;
+                await this._completeEntityOwnership(aid, type, undefined, () => {
+                    if (`${this._aid}:${this._serviceEventIdentityVersion}:${this._entityOwnershipConnection}` !== identity || this._closing || this._disconnecting)
+                        throw ownershipFailure('conflict', 'entity ownership connection changed');
+                });
+                return true;
+            })().catch(() => false);
+            this._entityOwnershipChecks.set(key, task);
+        }
+        await task;
+    }
+    async _completeEntityOwnership(aid, type, content, assertCurrent = () => { }) {
+        const store = this._aidStore;
+        const owner = this._currentAid;
+        const identity = `${this._aid}:${this._serviceEventIdentityVersion}:${this._entityOwnershipConnection}`, guard = assertCurrent;
+        assertCurrent = () => { guard(); if (`${this._aid}:${this._serviceEventIdentityVersion}:${this._entityOwnershipConnection}` !== identity || this._currentAid !== owner || this._aidStore !== store)
+            throw ownershipFailure('conflict', 'entity ownership connection changed'); };
+        if (!store || !owner?.isPrivateKeyValid())
+            throw ownershipFailure('unavailable', 'entity ownership requires the current owner private key', true);
+        const key = `${identity}:${aid}`, pending = this._entityOwnershipChecks.get(key);
+        if (content !== undefined && pending) {
+            await pending;
+            assertCurrent();
+        }
+        if (!this._entityOwnershipChecks.has(key))
+            this._entityOwnershipChecks.set(key, Promise.resolve(false));
+        const authority = await this._entityLifecycle(aid, type);
+        const result = authority;
+        const entity = (isJsonObject(result.group) ? result.group : isJsonObject(result.organization) ? result.organization : result);
+        if (entity.owner_aid !== owner.aid || entity.status !== 'active')
+            throw ownershipFailure('forbidden', 'entity ownership requires its current active lifecycle owner');
+        assertCurrent();
+        let local = store.load(aid);
+        if ((!local.ok || !local.data.aid.isPrivateKeyValid()) && type === 'group') {
+            const keystore = store._keystore;
+            let pending = null;
+            for (const id of new Set([String(entity.group_id ?? aid), aid])) {
+                pending = keystore?.loadPendingGroupBind?.(`bind:${id}`) ?? keystore?.loadPendingGroupBind?.(id);
+                if (pending?.private_key_pem && pending.public_key_der_b64)
+                    break;
+            }
+            if (pending?.private_key_pem && pending.public_key_der_b64) {
+                const certificate = await this._freshEntityCertificate(aid, type);
+                await this.verifyCertPublicKeyMatch(certificate.certPem, pending.public_key_der_b64, 'entity ownership recovery');
+                assertCurrent();
+                const imported = store.importGroupIdentity(aid, { ...pending, cert_pem: certificate.certPem });
+                if (!imported.ok)
+                    throw ownershipFailure('unavailable', imported.error.message, true);
+                local = store.load(aid);
+            }
+        }
+        if (!local.ok || !local.data.aid.isPrivateKeyValid())
+            throw ownershipFailure('unavailable', 'entity ownership requires its local private key', true);
+        const observed = await this._agentMdManager.readAgentMdFresh(aid);
+        const current = observed.exists ? validateAgentMdReadDocument(observed.content, { expectedAid: aid }).frontmatter : {};
+        const previous = isJsonObject(current.ownership) && isJsonObject(current.ownership.statement) ? current.ownership.statement : undefined;
+        if (!previous || previous.owner_aid === owner.aid) {
+            const consensus = await this.checkOwnershipConsensus(aid, true);
+            assertCurrent();
+            if (consensus.status === 'consensus' && consensus.owner_aid === owner.aid && content === undefined)
+                return observed.content;
+            if (!['consensus', 'unbound', 'single_sided'].includes(consensus.status))
+                throw ownershipFailure(consensus.code ?? 'conflict', consensus.reason ?? 'entity ownership cannot be repaired from current materials');
+        }
+        let version = Number(previous?.relation_version ?? 1);
+        if (previous && previous.owner_aid !== owner.aid) {
+            const authorization = await this._getOwnershipFiles().readOwner(String(previous.owner_aid), aid);
+            if (!authorization.exists)
+                throw ownershipFailure('conflict', 'entity transfer authorization is missing');
+            const verified = await this._getOwnershipFiles().verifyFile(authorization.content, 'owner', aid, String(previous.owner_aid));
+            if (verified.action !== 'transfer_owner' || verified.transfer?.new_owner_aid !== owner.aid || verified.transfer.target_relation_version !== version + 1 || verified.transfer.expires_at < Date.now() / 1000)
+                throw ownershipFailure('conflict', 'entity transfer authorization does not match');
+            version++;
+        }
+        const storage = this._getOwnershipStorage();
+        const original = await storage.readOwnerMd(owner.aid, aid);
+        let statement = previous?.owner_aid === owner.aid ? previous : { version: 2, declaration_id: crypto.randomUUID(), owner_aid: owner.aid, sub_aid: aid, relation_version: version, declared_at: Math.floor(Date.now() / 1000) };
+        if (original.exists) {
+            const verified = await this._getOwnershipFiles().verifyFile(original.content, 'owner', aid, owner.aid);
+            if (verified.action !== 'declare' || verified.statement?.relation_version !== version || verified.statement?.owner_aid !== owner.aid || verified.statement?.sub_aid !== aid)
+                throw ownershipFailure('conflict', 'entity owner declaration changed');
+            statement = verified.statement;
+        }
+        else {
+            const payload = `---\nowner_aid: ${owner.aid}\nsub_aid: ${aid}\nownership: ${JSON.stringify({ statement, action: 'declare' })}\n---\n`;
+            const raw = signOwnershipFile(owner, payload, 'owner');
+            assertCurrent();
+            await storage.writeOwnerMd(owner.aid, aid, raw, original, assertCurrent);
+        }
+        const source = content ?? (observed.exists ? observed.content : buildDefaultAgentMd(aid, { type, name: String(entity.name ?? aid) }));
+        const updated = updateOwnershipAgentMd(source, { owner: owner.aid, ownership: { statement } }).replace(/^entity_cert_fingerprint:.*(?:\r?\n|$)/m, '');
+        const signed = signOwnershipFile(local.data.aid, updated, 'agent');
+        if (content === undefined) {
+            if (!previous || previous.owner_aid !== owner.aid || previous.relation_version !== version) {
+                assertCurrent();
+                const uploaded = await store._uploadAgentMd(aid, signed, { uploaderAid: owner.aid, sourceGuard: assertCurrent, entityOwnerResolver: () => this._entityLifecycleOwner(aid, type), entityIdentityGetter: () => this._freshEntityCertificate(aid, type) });
+                if (!uploaded.ok)
+                    throw ownershipFailure('unavailable', uploaded.error.message, true);
+            }
+            const consensus = await this.checkOwnershipConsensus(aid, true);
+            assertCurrent();
+            if (consensus.status !== 'consensus' || consensus.owner_aid !== owner.aid || consensus.relation_version !== version)
+                throw ownershipFailure('unavailable', 'entity ownership publication could not be confirmed', true);
+        }
+        return signed;
+    }
     async _maybeHandleHalfOpenRpcFailure(err) {
         if (this._closing || this.state !== ConnectionState.READY)
             return;
@@ -1926,44 +2143,17 @@ export class AUNClient {
         if (!(err instanceof AUNError) || err.code !== -32003)
             return false;
         const message = String(err.message ?? '').trim();
-        const groupCertPrefix = 'valid group identity certificate is required for ';
-        if (message.toLowerCase().startsWith(groupCertPrefix)) {
-            const fallback = message.slice(groupCertPrefix.length).trim();
-            const store = this._aidStore;
-            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 }));
-            }
-            catch {
-                return false;
+        for (const prefix of ['valid group identity certificate is required for ', 'valid group agent.md is required for ']) {
+            if (message.toLowerCase().startsWith(prefix)) {
+                if (_method === 'group.get_info')
+                    return false;
+                const groupId = String(params.group_aid ?? params.groupAid ?? params.group_id ?? params.groupId ?? message.slice(prefix.length)).trim();
+                const target = normalizeGroupId(groupId.toLowerCase(), { localIssuer: this._aid?.split('.').slice(1).join('.') });
+                const key = `${this._aid}:${this._serviceEventIdentityVersion}:${this._entityOwnershipConnection}:${target}`;
+                if (!this._entityOwnershipChecks.has(key))
+                    await this._checkEntityOwnershipOnAccess('group.get_info', { group_id: groupId });
+                return await this._entityOwnershipChecks.get(key) ?? false;
             }
-            return true;
-        }
-        const groupMDPrefix = 'valid group agent.md is required for ';
-        if (message.toLowerCase().startsWith(groupMDPrefix)) {
-            const groupAid = message.slice(groupMDPrefix.length).trim();
-            const store = this._aidStore;
-            if (!groupAid || !store)
-                return false;
-            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;
         }
         const agentPrefix = 'valid agent.md is required for ';
         if (!message.toLowerCase().startsWith(agentPrefix))
@@ -2008,79 +2198,26 @@ export class AUNClient {
         if (!store)
             return;
         await this._resumeOrgIdentityAfterConnect(store);
-        let listed;
-        try {
-            listed = await this.call('group.list_my', {});
-        }
-        catch (exc) {
-            this._clientLog.warn(`post-connect group identity check failed: ${formatCaughtError(exc)}`);
-            return;
-        }
-        const result = isJsonObject(listed) ? listed : {};
-        const groups = Array.isArray(result.groups) ? result.groups : (Array.isArray(result.items) ? result.items : []);
-        for (const raw of groups) {
-            if (!isJsonObject(raw))
-                continue;
-            const group = raw;
-            const status = String(group.status ?? '').trim().toLowerCase();
-            if (status && status !== 'active')
-                continue;
-            const role = String(group.role ?? group.my_role ?? '').trim().toLowerCase();
-            const groupId = String(group.group_id ?? group.groupId ?? group.group_aid ?? group.groupAid ?? '').trim();
-            const groupAid = String(group.group_aid ?? group.groupAid ?? groupId).trim();
-            if (!groupId || !groupAid)
-                continue;
-            const keystore = store._keystore;
-            const pendingTransfer = keystore && typeof keystore.loadPendingGroupBind === 'function'
-                ? keystore.loadPendingGroupBind(`complete:${groupId}`)
-                : null;
-            if (role !== 'owner' && !pendingTransfer)
-                continue;
-            try {
-                await this._runGroupIdentityOperation(groupId, async () => {
-                    if (pendingTransfer) {
-                        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;
-                    }
-                    const checked = await this._agentMdManager.check(groupAid);
-                    if (!checked.remote_found) {
-                        await this._uploadGroupAgentMd(store, groupAid, {}, {});
-                    }
-                });
-            }
-            catch (exc) {
-                this._clientLog.warn(`post-connect group identity check failed: group=${groupId} err=${formatCaughtError(exc)}`);
-            }
-        }
     }
-    async _runGroupIdentityOperation(groupId, operation) {
+    async _runGroupIdentityOperation(groupId, operation, context = '') {
         const aid = String(this._aid ?? '').trim();
         const dot = aid.indexOf('.');
         const key = normalizeGroupId(groupId, { localIssuer: dot >= 0 ? aid.slice(dot + 1) : '' }).toLowerCase();
         if (!key)
             return operation();
-        let task = this._groupIdentityOperations.get(key);
+        const pending = this._groupIdentityOperations.get(key);
+        if (pending && pending.context !== context)
+            throw ownershipFailure('conflict', 'pending Org creation context changed');
+        let task = pending?.task;
         if (!task) {
             task = Promise.resolve().then(operation);
-            this._groupIdentityOperations.set(key, task);
+            this._groupIdentityOperations.set(key, { task, context });
         }
         try {
             return await task;
         }
         finally {
-            if (this._groupIdentityOperations.get(key) === task)
+            if (this._groupIdentityOperations.get(key)?.task === task)
                 this._groupIdentityOperations.delete(key);
         }
     }
@@ -2111,6 +2248,9 @@ export class AUNClient {
         return refreshed;
     }
     async createOrg(params = {}, options = {}) {
+        return this._runGroupIdentityOperation(`org-create:${this._aid}:${this._serviceEventIdentityVersion}:${String(params.org_id ?? '')}`, () => this._createOrg(params, options), new TextDecoder().decode(canonicalJson({ params, serviceAid: options.serviceAid ?? '' })));
+    }
+    async _createOrg(params, options) {
         const store = options.aidStore;
         const owner = this._currentAid;
         const orgAid = String(params.org_id ?? '').trim();
@@ -2334,21 +2474,28 @@ export class AUNClient {
         return result;
     }
     async _uploadOrgAgentMd(store, orgAid, params, initialResult) {
+        const assertCurrent = this._entityOwnershipGuard();
         const owner = this._currentAid;
         if (!owner)
             throw ownershipFailure('forbidden', 'Org agent.md requires current owner');
         const organization = isJsonObject(initialResult) && isJsonObject(initialResult.organization) ? initialResult.organization : undefined;
+        if (params.transfer_id && (organization?.org_id !== orgAid || organization.owner_aid !== owner.aid || organization.status !== 'active' || !isJsonObject(initialResult) || initialResult.transfer_id !== params.transfer_id))
+            throw ownershipFailure('conflict', 'Org transfer response does not match the completed transfer');
         const bootstrap = organization?.org_id === orgAid && organization.owner_aid === owner.aid && organization.status === 'active'
             ? { aid: orgAid, ownerAid: owner.aid, certFingerprint: this._localEntityCertificate(orgAid).certFingerprint, completedTransfer: Boolean(params.transfer_id && isJsonObject(initialResult) && initialResult.transfer_id === params.transfer_id) } : undefined;
         if (await this._resumeGroupAgentMdUpload(store, orgAid, bootstrap))
             return;
-        const identity = this._localEntityCertificate(orgAid);
-        const content = String(params.org_agent_md ?? buildDefaultAgentMd(orgAid, { type: 'org', owner: owner.aid, entityCertFingerprint: identity.certFingerprint, name: String(params.name ?? orgAid) }));
-        const uploaded = await store._uploadAgentMd(orgAid, content, { uploaderAid: owner.aid, entityOwnerResolver: (aid, type) => this._resolveEntityAgentMdOwner(aid, type, bootstrap), entityIdentityGetter: (aid) => this._freshEntityCertificate(aid, 'org') }, (aid, notice, manager) => this._getAgentMdChanges().committed(aid, notice, manager));
+        this._aidStore = store;
+        const content = await this._completeEntityOwnership(orgAid, 'org', String(params.org_agent_md ?? buildDefaultAgentMd(orgAid, { type: 'org', owner: owner.aid, name: String(params.name ?? orgAid) })), assertCurrent);
+        assertCurrent();
+        const uploaded = await store._uploadAgentMd(orgAid, content, { uploaderAid: owner.aid, sourceGuard: assertCurrent, entityOwnerResolver: (aid, type) => this._resolveEntityAgentMdOwner(aid, type, bootstrap), entityIdentityGetter: (aid) => this._freshEntityCertificate(aid, 'org') }, (aid, notice, manager) => this._getAgentMdChanges().committed(aid, notice, manager));
         if (!uploaded.ok) {
             const code = ['invalid', 'unavailable', 'forbidden', 'conflict', 'persistence_unavailable'].includes(uploaded.error.code) ? uploaded.error.code : uploaded.error.code === 'NETWORK_ERROR' ? 'unavailable' : 'invalid';
             throw ownershipFailure(code, uploaded.error.message, code === 'unavailable');
         }
+        const consensus = await this.checkOwnershipConsensus(orgAid, true);
+        if (consensus.status !== 'consensus' || consensus.owner_aid !== owner.aid)
+            throw ownershipFailure('unavailable', 'Org ownership publication could not be confirmed', true);
     }
     async createGroup(params = {}, options = {}) {
         if (!isJsonObject(params)) {
@@ -2529,13 +2676,14 @@ export class AUNClient {
         ].join('\n');
     }
     async _resumeGroupAgentMdUpload(store, groupAid, bootstrap) {
+        const assertCurrent = this._entityOwnershipGuard();
         const identityStore = store;
         const pendingManager = identityStore._agentMdManager ?? this._agentMdManager;
         const pending = pendingManager.pendingUpload(groupAid);
         if (!pending)
             return false;
         const fields = validateAgentMdDocument(pending.content, { expectedAid: groupAid, validateOwnership: false }).frontmatter;
-        if (['ownership', 'ownership_proof', 'ownership_release'].some((field) => Object.hasOwn(fields, field))) {
+        if (!['group', 'org'].includes(String(fields.type)) && ['ownership', 'ownership_proof', 'ownership_release'].some((field) => Object.hasOwn(fields, field))) {
             throw new StateError('ownership pending agent.md requires its persisted 2.1 task', { stringCode: 'unsupported_protocol' });
         }
         const identity = this._currentAid;
@@ -2549,6 +2697,7 @@ export class AUNClient {
             uploadViaGatewayHost: true,
             ownerAidGetter: () => identity.aid,
             currentAidGetter: () => identity,
+            sourceGuard: assertCurrent,
             entityOwnerResolver: (aid, type) => this._resolveEntityAgentMdOwner(aid, type, bootstrap?.completedTransfer || pending.condition?.if_none_match === '*' ? bootstrap : undefined),
             entityIdentityGetter: (aid, type) => this._freshEntityCertificate(aid, type),
             entitySignerResolver: (aid, fingerprint) => this._freshEntitySigner(aid, fingerprint),
@@ -2562,10 +2711,18 @@ export class AUNClient {
             },
             aidValidator: (aid) => identityStore._registerFlow.validateAidName(aid),
         });
-        return await manager.resumePendingUpload(groupAid);
+        const resumed = await manager.resumePendingUpload(groupAid);
+        assertCurrent();
+        if (resumed) {
+            const consensus = await this.checkOwnershipConsensus(groupAid, true);
+            if (consensus.status !== 'consensus' || consensus.owner_aid !== identity.aid)
+                throw ownershipFailure('unavailable', 'entity ownership recovery could not be confirmed', true);
+        }
+        return resumed;
     }
     async _uploadGroupAgentMd(store, groupAid, params, group, initialCertificate) {
         const uploaderAid = String(this._aid ?? '').trim();
+        const assertCurrent = this._entityOwnershipGuard();
         if (!uploaderAid) {
             throw new ValidationError('group agent.md upload requires current owner AID');
         }
@@ -2573,11 +2730,14 @@ export class AUNClient {
         const bootstrap = initialCertificate ? { aid: groupAid, ownerAid: String(group.owner_aid ?? '').trim(), certFingerprint: certFingerprint(initialCertificate), type: 'group' } : undefined;
         if (await this._resumeGroupAgentMdUpload(store, groupAid, bootstrap))
             return;
-        const uploaded = await store._uploadAgentMd(groupAid, this._groupAgentMdContent(groupAid, params, group), { uploaderAid, entityOwnerResolver: (aid, type) => this._resolveEntityAgentMdOwner(aid, type, bootstrap), entityIdentityGetter: (aid) => this._freshEntityCertificate(aid) }, (aid, notice, manager) => this._getAgentMdChanges().committed(aid, notice, manager));
+        const uploaded = await store._uploadAgentMd(groupAid, await this._completeEntityOwnership(groupAid, 'group', this._groupAgentMdContent(groupAid, params, group), assertCurrent), { uploaderAid, sourceGuard: assertCurrent, entityOwnerResolver: (aid, type) => this._resolveEntityAgentMdOwner(aid, type, bootstrap), entityIdentityGetter: (aid) => this._freshEntityCertificate(aid) }, (aid, notice, manager) => this._getAgentMdChanges().committed(aid, notice, manager));
         if (!uploaded.ok) {
             const code = ['invalid', 'unavailable', 'forbidden', 'conflict', 'persistence_unavailable'].includes(uploaded.error.code) ? uploaded.error.code : uploaded.error.code === 'NETWORK_ERROR' ? 'unavailable' : 'invalid';
             throw ownershipFailure(code, `group agent.md upload failed: ${uploaded.error.message}`, code === 'unavailable');
         }
+        const consensus = await this.checkOwnershipConsensus(groupAid, true);
+        if (consensus.status !== 'consensus' || consensus.owner_aid !== uploaderAid)
+            throw ownershipFailure('unavailable', 'group ownership publication could not be confirmed', true);
     }
     _localEntityCertificate(aid) {
         const loaded = this._aidStore?.load(aid);
@@ -2599,7 +2759,7 @@ export class AUNClient {
         try {
             authority = bootstrap?.completedTransfer && type === 'org' && bootstrap.aid === aid && bootstrap.ownerAid === this._currentAid?.aid
                 ? { owner_aid: bootstrap.ownerAid, entity_cert_fingerprint: bootstrap.certFingerprint }
-                : await this._agentMdManager.readEntityAuthorityFresh(aid);
+                : { owner_aid: await this._entityLifecycleOwner(aid, type), entity_cert_fingerprint: (await this._freshEntityCertificate(aid, type)).certFingerprint };
         }
         catch (error) {
             if (!bootstrap || bootstrap.aid !== aid || type !== (bootstrap.type ?? 'org') || !(error instanceof AUNError) || !isJsonObject(error.data) || error.data.http_status !== 404)
@@ -2613,6 +2773,26 @@ export class AUNClient {
             throw ownershipFailure('conflict', 'entity authority changed during current-certificate verification');
         return authority.owner_aid;
     }
+    async _entityLifecycle(aid, type) {
+        const method = type === 'group' ? 'group.get_info' : 'org.lifecycle.get';
+        let params = type === 'group' ? { group_id: aid, required: ['member'] } : { org_id: aid };
+        const signer = this._currentAid;
+        if (type === 'org' && signer) {
+            const records = this._tokenStore.loadMetadata?.(signer.aid)?.credential_renewals_v1 ?? {};
+            const record = Object.values(records).sort((left, right) => (right.membership_binding?.binding_version ?? 0) - (left.membership_binding?.binding_version ?? 0)).find(record => !record.successor_cid && record.credential?.iss === aid && record.credential?.sub === signer.aid && record.membership_binding?.org_id === aid && record.membership_binding?.member_aid === signer.aid);
+            if (record)
+                params = this.org.prepareRequest(method, { org_id: aid, fields: ['org_id', 'status', 'owner_aid'], credentials: { [record.membership_binding.role === 'admin' ? 'approval_credential' : 'member_credential']: record.credential, membership_binding: record.membership_binding } }, 'org.' + aid.slice(aid.indexOf('.') + 1), signer);
+        }
+        return this._rpcPipeline.call(method, params);
+    }
+    async _entityLifecycleOwner(aid, type) {
+        const response = await this._entityLifecycle(aid, type);
+        const data = response;
+        const entity = (isJsonObject(data.group) ? data.group : isJsonObject(data.organization) ? data.organization : data);
+        if (entity.status !== 'active' || typeof entity.owner_aid !== 'string')
+            throw ownershipFailure('unavailable', 'entity lifecycle owner is unavailable', true);
+        return entity.owner_aid;
+    }
     async bindGroupAid(params = {}, options = {}) {
         if (!isJsonObject(params)) {
             throw new ValidationError('bindGroupAid params must be an object');
@@ -3386,8 +3566,11 @@ export class AUNClient {
         this._delivery.markPublishedSeq(ns, seq);
     }
     _publishAppEvent(event, payload, source = 'direct', deliveryContext) {
-        if (messageClassOf(payload) === 'sdk_control')
-            return this._controlMessages().consume(payload);
+        if (messageClassOf(payload) === 'sdk_control') {
+            if (event === 'message.received')
+                return this._controlMessages().consume(payload);
+            return;
+        }
         if (event === 'message.received') {
             return this._handleOwnershipMessage(payload).then((handled) => {
                 if (!handled)
@@ -4325,13 +4508,17 @@ export class AUNClient {
         const extraInfo = (params.extra_info && typeof params.extra_info === 'object' && !Array.isArray(params.extra_info))
             ? { ...params.extra_info }
             : {};
+        const capabilities = isJsonObject(extraInfo._capabilities) ? { ...extraInfo._capabilities } : {};
+        delete capabilities.message_classes_v1;
         if (typeof this._tokenStore.updateInstanceState === 'function') {
-            extraInfo._capabilities = {
-                ...(isJsonObject(extraInfo._capabilities) ? extraInfo._capabilities : {}),
-                message_classes_v1: { p2p: ['normal', 'control', 'sdk_control'], group: ['normal', 'control', 'sdk_control'] },
-                sdk_control_protocols: { 'aun.agent_md.changed': [1] },
-            };
+            capabilities.message_classes_v2 = { p2p: ['normal', 'control', 'sdk_control'], group: ['normal', 'control'] };
+            capabilities.sdk_control_protocols = { 'aun.agent_md.changed': [1] };
         }
+        else {
+            delete capabilities.message_classes_v2;
+            delete capabilities.sdk_control_protocols;
+        }
+        extraInfo._capabilities = capabilities;
         const prevState = this._state;
         this._auth.setInstanceContext({ deviceId: this._deviceId, slotId: this._slotId });
         this._state = 'connecting';
@@ -4380,6 +4567,7 @@ export class AUNClient {
                     if (isJsonObject(auth.hello) && 'heartbeat_interval' in auth.hello) {
                         this._applyServerHeartbeatInterval(auth.hello.heartbeat_interval, 'auth');
                     }
+                    this._bindGatewayRuntimeIdentity(auth.hello, params);
                     this._gatewayConnectionId = isJsonObject(auth.hello) && isJsonObject(auth.hello.connection) ? String(auth.hello.connection.id ?? '') : '';
                     this._negotiatedCapabilities = isJsonObject(auth.hello) && isJsonObject(auth.hello.negotiated_capabilities) ? auth.hello.negotiated_capabilities : {};
                     if (isJsonObject(auth.hello))
@@ -4401,6 +4589,7 @@ export class AUNClient {
                 if (isJsonObject(hello) && 'heartbeat_interval' in hello) {
                     this._applyServerHeartbeatInterval(hello.heartbeat_interval, 'auth');
                 }
+                this._bindGatewayRuntimeIdentity(hello, params);
                 this._gatewayConnectionId = isJsonObject(hello) && isJsonObject(hello.connection) ? String(hello.connection.id ?? '') : '';
                 this._negotiatedCapabilities = isJsonObject(hello) && isJsonObject(hello.negotiated_capabilities) ? hello.negotiated_capabilities : {};
                 if (isJsonObject(hello))
@@ -4479,6 +4668,8 @@ export class AUNClient {
                     this._clientLog.warn(`schedule post-connect P2P gap fill failed: ${formatCaughtError(exc)}`);
                 });
             }
+            this._entityOwnershipConnection++;
+            this._entityOwnershipChecks.clear();
             if (!this._ownershipOperation)
                 this._safeAsync(this._checkIdentityAdmissionAfterConnect());
             this._clientLog.debug(`_connectOnce exit: elapsed=${Date.now() - tStart}ms gateway=${gatewayUrl}, aid=${this._aid ?? ''}`);
@@ -5200,13 +5391,17 @@ export class AUNClient {
         let lastErr = null;
         for (const url of candidates) {
             try {
+                const requestUrl = new URL(url);
+                if (resolvedAid === this._aid) {
+                    requestUrl.search = new URLSearchParams({ aid: resolvedAid, sdk_lang: 'typescript', sdk_version: VERSION, capabilities: 'gateway_migrate_v1' }).toString();
+                }
                 // discoverAll 是生产路径；若调用方注入了旧版/测试 discovery
                 // 替身而只提供 discover，则保留单候选兼容，不影响多候选发现。
                 const hasInjectedDiscover = Object.prototype.hasOwnProperty.call(discovery, 'discover')
                     && typeof discovery.discover === 'function';
                 const discovered = hasInjectedDiscover
-                    ? [await discovery.discover(url)]
-                    : await discovery.discoverAll(url);
+                    ? [await discovery.discover(requestUrl.toString())]
+                    : await discovery.discoverAll(requestUrl.toString());
                 if (!discoveryIsCurrent())
                     throw new StateError('gateway discovery superseded by identity change');
                 const gatewayUrls = [...new Set(discovered.map((item) => String(item ?? '').trim()).filter(Boolean))];
@@ -5560,6 +5755,18 @@ export class AUNClient {
     // ── 内部：断线重连 ────────────────────────────────────────
     /** 不重连 close code 集合：认证失败/权限错误/被踢等，重连无意义 */
     static _NO_RECONNECT_CODES = new Set([4001, 4003, 4008, 4009, 4010, 4011, 4013, 4014, 4015]);
+    _bindGatewayRuntimeIdentity(hello, params) {
+        const actual = isJsonObject(hello) && isJsonObject(hello.runtime_identity) ? hello.runtime_identity : null;
+        const metadata = this._discovery._gatewayMetadata?.get(this._gatewayUrl ?? '');
+        const expected = params._expected_gateway_runtime_identity ?? Object.fromEntries(['cluster_id', 'node_id', 'node_incarnation', 'service_instance_id'].filter((key) => metadata?.[key]).map((key) => [key, metadata[key]]));
+        if (isJsonObject(expected) && Object.entries(expected).some(([key, value]) => value !== actual?.[key])) {
+            throw new ConnectionError('gateway runtime identity changed');
+        }
+        const previousRevision = this._gatewayRuntimeIdentity?.cluster_id === actual?.cluster_id ? this._gatewayReleaseRevision : 0;
+        const revision = params._expected_gateway_release_revision ?? metadata?.release_revision;
+        this._gatewayReleaseRevision = Number.isSafeInteger(revision) && Number(revision) > 0 ? Math.max(previousRevision, Number(revision)) : previousRevision;
+        this._gatewayRuntimeIdentity = actual && Object.keys(actual).length > 0 ? actual : null;
+    }
     _onGatewayMigrate(input) {
         const data = input;
         if (!isJsonObject(data) || this._closing || this._disconnecting || this._connectAbort || this._reconnectActive
@@ -5570,6 +5777,7 @@ export class AUNClient {
         const now = Date.now() / 1000;
         if (typeof data.migration_id !== 'string' || !data.migration_id.trim()
             || typeof data.revision !== 'number' || !Number.isSafeInteger(data.revision) || data.revision <= 0
+            || data.revision < this._gatewayReleaseRevision
             || typeof data.issuer !== 'string' || data.issuer.trim().toLowerCase().replace(/\.$/, '') !== issuer
             || data.aid !== aid || data.device_id !== this._deviceId || data.slot_id !== this._slotId
             || data.connection_id !== this._gatewayConnectionId || typeof data.gateway_url !== 'string'
@@ -5589,6 +5797,14 @@ export class AUNClient {
             || !(hostname === issuer || hostname.endsWith(`.${issuer}`))
             || !hostname.split('.').every((label) => /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(label)))
             return;
+        if (this._gatewayReleaseRevision > 0 || ['cluster_id', 'source', 'target', 'release_revision'].some((key) => key in data)) {
+            const source = data.source, runtime = this._gatewayRuntimeIdentity, destination = data.target;
+            if (!runtime || !isJsonObject(source) || !isJsonObject(destination) || !data.cluster_id
+                || data.cluster_id !== runtime.cluster_id || destination.cluster_id !== data.cluster_id || data.release_revision !== data.revision
+                || ['cluster_id', 'node_id', 'node_incarnation', 'service_instance_id'].some((key) => typeof source[key] !== 'string' || !String(source[key]).trim() || source[key] !== runtime[key]
+                    || typeof destination[key] !== 'string' || !String(destination[key]).trim()))
+                return;
+        }
         const identity = JSON.stringify([this._aid, this._deviceId, this._slotId]);
         const previous = this._migrationRevision.get(identity);
         if (previous && (data.revision <= previous.revision || data.migration_id === previous.migrationId))
@@ -5653,7 +5869,8 @@ export class AUNClient {
                     this._state = 'reconnecting';
                     this._migrationPending = true;
                     try {
-                        await wait(this._connectOnce({ ...this._sessionParams, gateway, gateways: candidates }, true, owner));
+                        await wait(this._connectOnce({ ...this._sessionParams, gateway, gateways: candidates,
+                            ...(attempt === 1 && index === 0 && isJsonObject(data.target) ? { _expected_gateway_runtime_identity: data.target, _expected_gateway_release_revision: data.release_revision } : {}), }, true, owner));
                         if (!current())
                             return;
                         if (!this._transport.isConnected())
@@ -5673,7 +5890,7 @@ export class AUNClient {
                         if (attempt === 1 && index === 0) {
                             try {
                                 const discovered = await wait(this._resolveGatewayCandidatesForAid(String(data.aid), true, owner));
-                                candidates = [...candidates, ...discovered.filter((item) => !candidates.includes(item))];
+                                candidates = [...candidates, ...discovered.filter((item) => item === gateway || !candidates.includes(item))];
                             }
                             catch (discoveryError) {
                                 lastError = discoveryError;
@@ -6014,7 +6231,10 @@ export class AUNClient {
                         this._sessionParams.access_token = '';
                     }
                 }
-                const candidates = this._orderedReconnectGateways(this._sessionParams);
+                const candidates = await this._lifecycle.waitForAttempt(this._resolveGatewayCandidatesForAid(this._aid, true, reconnectAbort ?? undefined), undefined, reconnectAbort ?? undefined);
+                if (!this._ownsReconnect(reconnectAbort))
+                    return;
+                this._sessionParams.gateways = [...candidates];
                 let lastGatewayError = null;
                 let connected = false;
                 for (const gateway of candidates) {