@agentunion/fastaun-browser 0.5.18 → 0.5.19

package/dist/client.js

@@ -9,6 +9,7 @@ import { EventDispatcher } from './events.js';
 import { normalizeGroupId } from './group-id.js';
 import { validateAIDFormat, validateGroupIDFormat } from './validators.js';
 import { GatewayDiscovery } from './discovery.js';
+import { AIDStore } from './aid-store.js';
 import { RPCTransport } from './transport.js';
 import { AuthFlow } from './auth.js';
 import { SeqTracker } from './seq-tracker.js';
@@ -19,22 +20,28 @@ import { IdentityRuntimeManager } from './client/identity.js';
 import { LifecycleController } from './client/lifecycle.js';
 import { PeerDirectory } from './client/peers.js';
 import { RpcPipeline } from './client/rpc-pipeline.js';
-import { GroupFacade, MailFacade, MessageFacade, StreamFacade } from './facades.js';
+import { CredentialFacade, GroupFacade, MailFacade, MessageFacade, OrgFacade, StreamFacade } from './facades.js';
 import { StorageVFS } from './storage/vfs.js';
 import { CollabClient } from './collab/client.js';
 import { V2E2EECoordinator } from './client/v2-e2ee.js';
 import { GroupStateCoordinator } from './client/group-state.js';
-import { CryptoProvider, base64ToUint8, pemToArrayBuffer, ecdsaVerifyDer, importCertPublicKeyEcdsa, } from './crypto.js';
+import { CryptoProvider, base64ToUint8, pemToArrayBuffer, certificateSha256Fingerprint, ecdsaVerifyDer, importCertPublicKeyEcdsa, arrayBufferToPem, uint8ToBase64, } from './crypto.js';
 import { IndexedDBTokenStore } from './keystore/indexeddb-token-store.js';
 import { decryptMessage, } from './v2/e2ee/index.js';
 import { ecdsaVerifyRaw } from './v2/crypto/ecdsa.js';
+import { decryptedOwnershipJsonText } from './v2/e2ee/decrypt.js';
 import { AUNLogger } from './logger.js';
-import { AgentMdManager, buildDefaultAgentMd } from './agent-md.js';
+import { AgentMdManager, buildDefaultAgentMd, buildOwnershipAgentMd, buildOwnershipReleaseAgentMd } from './agent-md.js';
 import { GroupIndexMetaCache } from './group-index.js';
-import { certMatchesFingerprint, normalizeFingerprintHex, parseCertMetadata } from './cert-utils.js';
+import { certMatchesFingerprint, normalizeFingerprintHex, parseAgentMdTailSignature, parseCertMetadata } from './cert-utils.js';
+import { validateAgentMdDocument } from './agent-md-schema.js';
 import { AUNError, AuthError, ConnectionError, E2EEError, NotFoundError, PermissionError, StateError, TimeoutError, ValidationError, } from './errors.js';
 import { isJsonObject, ConnectionState, STATE_TO_PUBLIC, } from './types.js';
 import { AID } from './aid.js';
+import { OwnershipFiles, OwnershipStorageAdapter, ownershipSha256 } from './ownership-v21.js';
+import { canonicalJson, createCredential, createMemberCredential, signMembershipBinding, verifyServiceEvent } from './org-protocol.js';
+import { OwnershipWorkflow, parseOwnershipRegistrationIntent } from './ownership-workflow.js';
+import { buildOwnershipMessage, encryptIdentity, decryptIdentity, } from './ownership-proof.js';
 function getV2DeviceId(dev) {
     if (Object.prototype.hasOwnProperty.call(dev, 'device_id')) {
         return { present: true, value: String(dev.device_id ?? '').trim() };
@@ -52,9 +59,22 @@ function isAIDObject(value) {
         && typeof candidate.aunPath === 'string'
         && typeof candidate.isPrivateKeyValid === 'function');
 }
+function ownershipRandomUUID() {
+    return globalThis.crypto?.randomUUID?.()
+        ?? 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (char) => {
+            const random = Math.floor(Math.random() * 16);
+            const value = char === 'x' ? random : (random & 0x3) | 0x8;
+            return value.toString(16);
+        });
+}
 function bytesToHex(bytes) {
     return Array.from(bytes).map((b) => b.toString(16).padStart(2, '0')).join('');
 }
+function randomBase64Url(byteLength) {
+    const bytes = new Uint8Array(byteLength);
+    globalThis.crypto.getRandomValues(bytes);
+    return uint8ToBase64(bytes).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+}
 function exactArrayBuffer(bytes) {
     return bytes.slice().buffer;
 }
@@ -240,6 +260,9 @@ function createAgentMdManagerForRuntime(opts) {
         logger: opts.logger(),
         ownerAidGetter: opts.ownerAid,
         currentAidGetter: opts.currentAid,
+        entityOwnerResolver: opts.entityOwnerResolver,
+        entityIdentityGetter: opts.entityIdentityGetter,
+        entitySignerResolver: opts.entitySignerResolver,
         gatewayResolver: async (aid) => {
             const gatewayUrl = await opts.gateway.resolve(aid);
             opts.gateway.set(gatewayUrl);
@@ -289,7 +312,46 @@ function createAgentMdManagerForRuntime(opts) {
             opts.identity.set(await auth.loadIdentityOrNone(target) ?? fallbackIdentity);
             return token;
         },
-        peerResolver: async (aid, certFingerprint) => {
+        uploadAccessTokenResolver: async (_aid, gatewayUrl) => {
+            const target = String(opts.ownerAid() ?? '').trim();
+            let identity = opts.identity.get();
+            if (!identity || String(identity.aid ?? '') !== target)
+                throw new StateError('no local identity found, register or load an AID first');
+            const auth = opts.auth();
+            const cachedToken = String(identity.access_token ?? '');
+            const expiresAt = auth.getAccessTokenExpiry(identity);
+            if (cachedToken && (expiresAt === null || expiresAt > Date.now() / 1000 + 30))
+                return cachedToken;
+            if (identity.refresh_token) {
+                try {
+                    const refreshed = await auth.refreshCachedTokens(gatewayUrl, identity);
+                    const refreshedToken = String(refreshed.access_token ?? '');
+                    const refreshedExpiry = auth.getAccessTokenExpiry(refreshed);
+                    if (refreshedToken && (refreshedExpiry === null || refreshedExpiry > Date.now() / 1000 + 30)) {
+                        opts.identity.set(refreshed);
+                        return refreshedToken;
+                    }
+                }
+                catch {
+                    // refresh 失败时回退到完整 authenticate。
+                }
+            }
+            const result = await auth.authenticate(gatewayUrl, target);
+            const token = String(result.access_token ?? '');
+            if (!token)
+                throw new StateError('authenticate did not return access_token');
+            const fallbackIdentity = {
+                ...identity,
+                access_token: token,
+                refresh_token: String(result.refresh_token ?? identity.refresh_token ?? ''),
+            };
+            const fallbackExpiresAt = Number(result.expires_at ?? identity.expires_at ?? NaN);
+            if (Number.isFinite(fallbackExpiresAt))
+                fallbackIdentity.expires_at = fallbackExpiresAt;
+            opts.identity.set(await auth.loadIdentityOrNone(target) ?? fallbackIdentity);
+            return token;
+        },
+        peerResolver: async (aid, certFingerprint, signedAt) => {
             const target = String(aid ?? '').trim();
             const expectedFp = String(certFingerprint ?? '').trim().toLowerCase();
             const current = opts.currentAid();
@@ -303,7 +365,7 @@ function createAgentMdManagerForRuntime(opts) {
                 }
                 catch { /* best effort */ }
             }
-            const certPem = String(await opts.fetchPeerCert(target, expectedFp || undefined) ?? '').trim();
+            const certPem = String(await opts.fetchPeerCert(target, expectedFp || undefined, signedAt) ?? '').trim();
             if (!certPem)
                 throw new NotFoundError(`certificate not found for aid: ${target}`);
             return await AID.create({
@@ -520,14 +582,79 @@ function normalizeDeliveryModeConfig(raw, opts = {}) {
  *
  */
 export class AUNClient {
+    resolveCredentialService;
     /** SDK 配置模型 */
     configModel;
     /** 原始配置字典 */
     config;
     _aid = null;
+    _serviceEventIdentityVersion = 0;
     _identity = null;
     _state = 'idle';
     _currentAid = null;
+    _ownershipRecords = new Map();
+    _ownershipType = 'agent';
+    _ownershipRecordsLoad = null;
+    _ownershipWorkflow = null;
+    _ownershipRecoveryTimer = null;
+    _ownershipRecoveryGeneration = 0;
+    _ownershipReleaseTasks = new Map();
+    async _persistOwnershipRecords() {
+        const aid = String(this._aid ?? '').trim();
+        if (!aid)
+            return;
+        const store = this._tokenStore;
+        if (!store.getMetadata || !store.setMetadata)
+            return;
+        let records = {};
+        try {
+            const raw = await store.getMetadata.call(store, aid, 'ownership_records');
+            const parsed = raw ? JSON.parse(raw) : {};
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+                records = parsed;
+        }
+        catch {
+            records = {};
+        }
+        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)));
+        }
+        await store.setMetadata.call(store, aid, 'ownership_records', JSON.stringify(records));
+    }
+    async _restoreOwnershipRecords() {
+        const aid = String(this._aid ?? '').trim();
+        if (!aid)
+            return;
+        const store = this._tokenStore;
+        if (!store.getMetadata)
+            return;
+        try {
+            const intentRaw = await store.getMetadata.call(store, aid, 'registration_intent');
+            if (this._aid !== aid)
+                return;
+            if (intentRaw)
+                this._ownershipType = String(JSON.parse(intentRaw).type || this._ownershipType);
+            const raw = await store.getMetadata.call(store, aid, 'ownership_records');
+            if (this._aid !== aid)
+                return;
+            const records = raw ? JSON.parse(raw) : {};
+            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 ?? '').trim().toLowerCase() === aid.toLowerCase())
+                    this._ownershipType = String(record.type ?? this._ownershipType);
+            }
+        }
+        catch {
+            return;
+        }
+    }
     _instanceProtectedHeaders = null;
     _gatewayUrl = null;
     _gatewayCandidates = [];
@@ -537,6 +664,7 @@ export class AUNClient {
     _connectDeliveryMode;
     _defaultConnectDeliveryMode;
     _closing = false;
+    _disconnecting = false;
     _sessionParams = null;
     _sessionOptions = { ...DEFAULT_SESSION_OPTIONS };
     _dispatcher;
@@ -560,6 +688,10 @@ export class AUNClient {
     _v2BootstrapCache = new Map();
     _v2SenderIKPending = new Map();
     _v2SenderIKFetching = new Set();
+    _readStateCache = new Map();
+    _readStateQueries = new Map();
+    _readStateIdentity = null;
+    _readStateGeneration = 0;
     static V2_BOOTSTRAP_TTL_MS = 60 * 60 * 1000;
     /** V2 state 签名验证缓存：cacheKey(hex) → expiry_unix_ms */
     _v2SigCache = new Map();
@@ -643,6 +775,8 @@ export class AUNClient {
     _mailFacade;
     _groupFacade;
     _streamFacade;
+    _credentialFacade;
+    _orgFacade;
     _groupInvitePending = new Map();
     _groupInviteStateAid = null;
     _groupInviteStateLoad = null;
@@ -691,6 +825,9 @@ export class AUNClient {
             verifySsl: this.configModel.verifySsl,
         });
         this._aid = initAid;
+        this._dispatcher.setEventIdentity(initAid ?? '');
+        if (initAid)
+            this._ownershipRecordsLoad = this._restoreOwnershipRecords();
         this._agentMdManager = createAgentMdManagerForRuntime({
             config: () => this.configModel,
             logger: () => this._logger.for('aun_core.agent_md'),
@@ -708,13 +845,18 @@ export class AUNClient {
             },
             auth: () => this._auth,
             tokenStore: () => this._tokenStore,
-            fetchPeerCert: (target, certFingerprint) => this._fetchPeerCert(target, certFingerprint || undefined),
+            fetchPeerCert: (target, certFingerprint, signedAt) => this._fetchPeerCert(target, certFingerprint || undefined, undefined, signedAt),
+            entityOwnerResolver: (target, type) => this._resolveEntityAgentMdOwner(target, type),
+            entityIdentityGetter: (target, type) => this._freshEntityCertificate(target, type),
+            entitySignerResolver: (target, fingerprint) => this._freshEntitySigner(target, fingerprint),
         });
         this._transport = new RPCTransport({
             eventDispatcher: this._dispatcher,
             timeout: DEFAULT_SESSION_OPTIONS.timeouts.call,
         });
+        this._transport.setServiceEventVerifier((event, payload) => this._verifyIncomingServiceEvent(event, payload));
         this._transport.setProtocolDisconnectCallback((error, closeCode) => this._handleTransportDisconnect(error, closeCode));
+        this._transport._onForegroundDrained = () => this._delivery.onForegroundPullsDrained();
         this._transport.setProtocolMetaObserver((meta) => this._observeRpcMeta(meta).catch((exc) => {
             this._clientLog.debug(`rpc meta observer skipped: ${String(exc)}`);
         }));
@@ -736,6 +878,7 @@ export class AUNClient {
                     cert: inputAid.certPem,
                 };
                 this._auth.setIdentity(this._identity);
+                this._ownershipRecordsLoad = this._restoreOwnershipRecords();
                 this._state = 'standby';
             }
         }
@@ -756,6 +899,9 @@ export class AUNClient {
         this._dispatcher.subscribeProtocol('_raw.message.recalled', (data) => {
             this._safeAsync(this._onRawMessageRecalled(data));
         });
+        this._dispatcher.subscribeProtocol('_raw.message.read_changed', (data) => {
+            this._onRawReadChanged(data, 'p2p');
+        });
         // 群组消息推送：re-publish（V2 加密消息走 V2 push 路径）
         this._dispatcher.subscribeProtocol('_raw.group.message_created', (data) => {
             this._onRawGroupMessageCreated(data);
@@ -764,6 +910,9 @@ export class AUNClient {
         this._dispatcher.subscribeProtocol('_raw.group.message_recalled', (data) => {
             this._safeAsync(this._onRawGroupMessageRecalled(data));
         });
+        this._dispatcher.subscribeProtocol('_raw.group.read_changed', (data) => {
+            this._onRawReadChanged(data, 'group');
+        });
         // 群组变更事件：验签 + 透传 + gap 检测 + V2 state/SPK 维护
         this._dispatcher.subscribeProtocol('_raw.group.changed', (data) => {
             this._onRawGroupChanged(data);
@@ -894,6 +1043,18 @@ export class AUNClient {
             this._mailFacade = new MailFacade(this);
         return this._mailFacade;
     }
+    /** Credential RPC facade 入口 */
+    get credential() {
+        if (!this._credentialFacade)
+            this._credentialFacade = new CredentialFacade(this);
+        return this._credentialFacade;
+    }
+    /** Org RPC facade 入口 */
+    get org() {
+        if (!this._orgFacade)
+            this._orgFacade = new OrgFacade(this);
+        return this._orgFacade;
+    }
     getGroupIndexRemoteMeta(groupAid) {
         return this._groupIndexMetaCache.remoteMeta(this._aid ?? '', groupAid);
     }
@@ -978,6 +1139,501 @@ 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'; }
+    get_type() { 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) {
+                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;
+    }
+    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() { return this.getOwnershipStatus(); }
+    _ownershipEscrowPath(subjectAid, proofId) {
+        return `/.aun/ownership/${String(subjectAid ?? '').trim().toLowerCase()}/${String(proofId ?? '').trim()}.json`;
+    }
+    async _uploadOwnershipEscrow(subjectAid, ownerAid, proofId) {
+        const current = this._currentAid;
+        if (!current || !current.isPrivateKeyValid())
+            throw new StateError('ownership escrow requires a loaded identity with a valid private key');
+        const packageValue = { aid: current.aid, private_key_pem: current.privateKeyPem, public_key_der_b64: current.publicKey, curve: 'P-256', cert: current.certPem };
+        const { envelope, password } = await encryptIdentity(packageValue);
+        const path = this._ownershipEscrowPath(subjectAid, proofId);
+        await this.storage.writeBytes(path, new TextEncoder().encode(JSON.stringify(envelope)), { overwrite: true, contentType: 'application/json' });
+        await this.storage.setAcl(path, { granteeAid: ownerAid, perms: 'r' });
+        const ticket = await this.storage.lowlevel.call('storage.create_download_ticket', {
+            owner_aid: subjectAid, bucket: 'default', object_key: path.replace(/^\/+/, ''), viewer_aid: ownerAid,
+        }, path);
+        const downloadUrl = String(ticket.logical_url ?? ticket.download_url ?? ticket.url ?? '').trim();
+        if (!downloadUrl)
+            throw new ValidationError('ownership escrow download ticket did not return a URL');
+        return { escrow_path: path, escrow_download_url: downloadUrl, escrow_password: password, escrow_sha256: envelope.sha256 };
+    }
+    async _downloadOwnershipEscrow(record) {
+        const subject = String(record.subject_aid ?? '').trim().toLowerCase();
+        const downloadUrl = String(record.escrow_download_url ?? '').trim();
+        const password = String(record.escrow_password ?? '');
+        if (!subject || !downloadUrl || !password)
+            throw new ValidationError('ownership escrow metadata is incomplete');
+        const currentAid = String(this._aid ?? '').trim().toLowerCase();
+        const currentIssuer = currentAid.includes('.') ? currentAid.slice(currentAid.indexOf('.') + 1) : '';
+        const subjectIssuer = subject.includes('.') ? subject.slice(subject.indexOf('.') + 1) : '';
+        const sameIssuer = currentAid === subject || Boolean(currentIssuer && subjectIssuer && currentIssuer === subjectIssuer);
+        const token = sameIssuer ? this.getAccessToken() : null;
+        const raw = await this.storage.lowlevel.httpGet(downloadUrl, token ? { Authorization: 'Bearer ' + token } : undefined);
+        const envelope = JSON.parse(new TextDecoder().decode(raw));
+        const identity = await decryptIdentity(envelope, password);
+        if (String(identity.aid ?? '').trim().toLowerCase() !== subject)
+            throw new ValidationError('ownership escrow identity AID mismatch');
+        const store = this._aidStore ?? new AIDStore({ aunPath: this.configModel.aunPath, encryptionSeed: this.configModel.seedPassword ?? '' });
+        this._aidStore = store;
+        const imported = await store.importGroupIdentity(subject, identity);
+        if (!imported.ok)
+            throw new StateError(imported.error?.message ?? 'ownership custody identity persistence failed');
+        record.subject_identity = identity;
+        record.escrow_sha256 = String(envelope.sha256 ?? '');
+        return identity;
+    }
+    _ownershipV21() {
+        if (!this._ownershipWorkflow) {
+            const storage = new OwnershipStorageAdapter({ currentAid: () => this._aid ?? '', call: (method, params) => this.call(method, params) });
+            const files = new OwnershipFiles({
+                currentAidType: () => this.getType(),
+                currentAid: () => {
+                    if (!this._currentAid?.isPrivateKeyValid() || this._currentAid.aid !== this._aid)
+                        throw new StateError('ownership signing requires the current local identity', { stringCode: 'forbidden' });
+                    return this._currentAid;
+                },
+                readAgentMdFresh: (aid) => this._agentMdManager.readOwnershipFresh(aid),
+                submitAgentMdRaw: (aid, raw, condition) => this._agentMdManager.submitOwnershipRaw(aid, raw, condition),
+                readOwnerMd: (owner, sub) => storage.readOwnerMd(owner, sub),
+                writeOwnerMd: (owner, sub, raw, revision) => storage.writeOwnerMd(owner, sub, raw, revision),
+                deleteOwnerMd: (owner, sub, revision) => storage.deleteOwnerMd(owner, sub, revision),
+                resolveCertificate: async (aid, fingerprint, keyPurpose) => this._auth.resolveOwnershipCertificate(await this._resolveOwnershipCertificateGateway(aid), aid, fingerprint, keyPurpose),
+            });
+            this._ownershipWorkflow = new OwnershipWorkflow({
+                currentAidType: () => this.getType(),
+                currentAid: () => this._aid ?? '', store: this._tokenStore, files,
+                send: (to, payload, messageId) => this.call('message.send', { to, payload: payload, encrypt: true, message_id: messageId }),
+                emit: (event, payload) => this._dispatcher.publish(event, payload),
+            });
+        }
+        return this._ownershipWorkflow;
+    }
+    async bindOwneraid(ownerAid) { return await this._ownershipV21().bindOwneraid(ownerAid); }
+    async bindSubaid(subAid) { return await this._ownershipV21().bindSubaid(subAid); }
+    async releaseSubaid(subAid) { return await this._ownershipV21().releaseSubaid(subAid); }
+    async transferSubaid(subAid, newOwnerAid) { return await this._ownershipV21().transferSubaid(subAid, newOwnerAid); }
+    async checkOwnershipConsensus(subAid) { return await this._ownershipV21().checkOwnershipConsensus(subAid); }
+    async _resumeOwnershipAfterConnect() {
+        await this._checkIdentityAdmissionAfterConnect();
+        await this._resumeRegistrationIntent();
+        await this._ownershipV21().resume();
+    }
+    async _resumeRegistrationIntent(guard) {
+        guard?.();
+        if (!this._aid)
+            return;
+        const store = this._tokenStore;
+        if (typeof store.getMetadata !== 'function' || typeof store.setMetadata !== 'function')
+            throw new StateError('ownership registration storage unavailable', { stringCode: 'persistence_unavailable' });
+        let raw;
+        try {
+            raw = await store.getMetadata(this._aid, 'registration_intent');
+        }
+        catch (error) {
+            throw new StateError(`ownership registration read failed: ${String(error)}`, { stringCode: 'persistence_unavailable' });
+        }
+        if (!raw)
+            return;
+        const intent = parseOwnershipRegistrationIntent(raw, this._aid);
+        if (intent.protocol === 'entity')
+            return;
+        if (!intent.pending)
+            return;
+        if (!intent.operation_id)
+            throw new StateError('ownership registration intent is damaged', { stringCode: 'persistence_unavailable' });
+        guard?.();
+        await this._ownershipV21().startRegistrationIntent(intent.owner, intent.operation_id, guard);
+        guard?.();
+        try {
+            await store.setMetadata(this._aid, 'registration_intent', JSON.stringify({ ...intent, pending: false }));
+        }
+        catch (error) {
+            throw new StateError(`ownership registration save failed: ${String(error)}`, { stringCode: 'persistence_unavailable' });
+        }
+    }
+    async _recoverOwnershipRekeyBeforeConnect() {
+        await this._ownershipRecordsLoad;
+        if (!['standby', 'authenticated', 'retry_backoff', 'connection_failed'].includes(this.state))
+            return;
+        for (const [key, record] of this._ownershipRecords) {
+            if (record.subject_aid !== this._aid || !['pending_rekey', 'pending_agent_md', 'pending_upload'].includes(String(record.release_status ?? '')))
+                continue;
+            const store = this._aidStore ?? new AIDStore({ aunPath: this.configModel.aunPath, encryptionSeed: this.configModel.seedPassword ?? '', verifySsl: this.configModel.verifySsl });
+            this._aidStore = store;
+            let loaded = await store.load(String(record.subject_aid));
+            if (!loaded.ok)
+                throw new StateError(loaded.error.message);
+            if (record.release_status === 'pending_rekey' && loaded.data.aid.certFingerprint === record.release_old_fingerprint) {
+                const rekeyed = await store.rekey(loaded.data.aid.aid);
+                if (!rekeyed.ok)
+                    throw new StateError(rekeyed.error.message);
+                loaded = await store.load(String(record.subject_aid));
+                if (!loaded.ok)
+                    throw new StateError(loaded.error.message);
+            }
+            if (record.release_status === 'pending_rekey')
+                record.release_status = 'pending_agent_md';
+            this._ownershipRecords.set(key, record);
+            await this._persistOwnershipRecords();
+            if (this._currentAid?.certFingerprint !== loaded.data.aid.certFingerprint) {
+                this._state = 'no_identity';
+                this.loadIdentity(loaded.data.aid);
+            }
+        }
+    }
+    async _sendOwnershipControl(params) {
+        const payload = params.payload;
+        const key = this._ownershipKey(String(payload.subject_aid), String(payload.owner_aid));
+        const record = this._ownershipRecords.get(key);
+        record.pending_message = params;
+        if (payload.action === 'bind.response' || payload.action === 'bind.reject')
+            delete record.ownership_request_pending;
+        if (payload.action === 'bind.reject')
+            record.status = 'rejected';
+        await this._persistOwnershipRecords();
+        const result = await this.call('message.send', params);
+        delete record.pending_message;
+        await this._persistOwnershipRecords();
+        return result;
+    }
+    async _resumeOwnership() {
+        await this._ownershipRecordsLoad;
+        const current = String(this._aid ?? '').toLowerCase();
+        for (const [key, record] of this._ownershipRecords) {
+            const subject = String(record.subject_aid ?? ''), owner = String(record.owner_aid ?? '');
+            try {
+                if (record.pending_message)
+                    await this._sendOwnershipControl(record.pending_message);
+                if (record.ownership_request_pending) {
+                    const role = current === subject ? 'owner' : 'subject';
+                    await this._dispatcher.publish('ownership.request', {
+                        request_id: record.request_id, proof_id: record.proof_id, subject_aid: subject, owner_aid: owner, subject_type: record.type,
+                        requester_aid: current === subject ? owner : subject, requester_role: role, statement: record[`${role}_statement`], signature: record[`${role}_signature`],
+                    });
+                    continue;
+                }
+                if (record.status !== 'active' || record.release_status)
+                    continue;
+                if (subject === owner) {
+                    if (!record.agent_md_uploaded)
+                        await this._publishSubjectOwnershipAgentMd(record);
+                }
+                else if (current === subject && !record.agent_md_synced) {
+                    await this._publishSubjectOwnershipAgentMd(record);
+                    Object.assign(record, await this._uploadOwnershipEscrow(subject, owner, String(record.proof_id)));
+                    await this.call('message.send', { to: owner, encrypt: true, payload: buildOwnershipMessage('escrow.ready', {
+                            requestId: String(record.request_id), proofId: String(record.proof_id), subjectAid: subject, ownerAid: owner, subject_type: record.type,
+                            escrow_path: record.escrow_path, escrow_download_url: record.escrow_download_url, escrow_password: record.escrow_password, escrow_sha256: record.escrow_sha256,
+                        }) });
+                }
+                else if (current === owner && !record.agent_md_notified) {
+                    const store = this._aidStore ?? new AIDStore({ aunPath: this.configModel.aunPath, encryptionSeed: this.configModel.seedPassword ?? '' });
+                    this._aidStore = store;
+                    const loaded = await store.load(subject);
+                    const signature = record.subject_signature;
+                    if (!loaded.ok || !loaded.data.aid.isPrivateKeyValid() || loaded.data.aid.certFingerprint !== signature?.cert_fingerprint) {
+                        await this._sendOwnershipControl({ to: subject, encrypt: true, payload: buildOwnershipMessage('bind.response', {
+                                requestId: String(record.request_id), proofId: String(record.proof_id), subjectAid: subject, ownerAid: owner,
+                                subject_type: record.type, statement: record.owner_statement, signature: record.owner_signature,
+                            }) });
+                        continue;
+                    }
+                    await this._publishOwnershipAgentMd(record);
+                    await this.call('message.send', { to: subject, encrypt: true, payload: buildOwnershipMessage('agent_md.updated', {
+                            requestId: String(record.request_id), proofId: String(record.proof_id), subjectAid: subject, ownerAid: owner,
+                        }) });
+                    record.agent_md_notified = true;
+                }
+                delete record.last_error;
+                this._ownershipRecords.set(key, record);
+                await this._persistOwnershipRecords();
+            }
+            catch (error) {
+                record.last_error = error instanceof Error ? error.message : String(error);
+                this._ownershipRecords.set(key, record);
+                await this._persistOwnershipRecords();
+            }
+        }
+    }
+    async _ownershipAgentMdContent(record, content = '') {
+        const subject = String(record.subject_aid ?? '').trim().toLowerCase();
+        const owner = String(record.owner_aid ?? '').trim().toLowerCase();
+        const proof = { proof_id: String(record.proof_id ?? ''), subject_aid: subject, owner_aid: owner };
+        if (record.subject_signature)
+            proof.subject_signature = record.subject_signature;
+        if (record.owner_signature && subject !== owner)
+            proof.owner_signature = record.owner_signature;
+        const base = content || await this._agentMdManager.readContent(subject) || buildDefaultAgentMd(subject, { type: String(record.type ?? 'agent') || 'agent' });
+        return buildOwnershipAgentMd(base, owner, proof);
+    }
+    async _publishSubjectOwnershipAgentMd(record, uploadPartial = false) {
+        const subject = String(record.subject_aid ?? '').trim().toLowerCase();
+        if (!this._currentAid?.isPrivateKeyValid() || this._currentAid.aid.toLowerCase() !== subject)
+            return;
+        if (record.subject_proof_published && !uploadPartial)
+            return;
+        const content = await this._ownershipAgentMdContent(record);
+        try {
+            const pending = await this._agentMdManager.pendingUpload(subject);
+            const proof = validateAgentMdDocument(content).frontmatter.ownership_proof;
+            if (pending && JSON.stringify(validateAgentMdDocument(pending.content).frontmatter.ownership_proof) === JSON.stringify(proof))
+                await this._agentMdManager.resumePendingUpload(subject, this._currentAid);
+            else {
+                await this._agentMdManager.writeContent(subject, content);
+                await this._agentMdManager.upload(content);
+            }
+            record.agent_md_uploaded = true;
+            if (record.subject_signature && (record.owner_signature || subject === record.owner_aid))
+                record.subject_proof_published = true;
+            await this._persistOwnershipRecords();
+        }
+        catch (error) {
+            this._clientLog.debug('ownership partial agent.md upload deferred: ' + (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    async _publishOwnershipAgentMd(record) {
+        if (record.agent_md_uploaded || !record.owner_signature || !record.subject_signature)
+            return;
+        if (!record.subject_identity) {
+            const store = this._aidStore ?? new AIDStore({ aunPath: this.configModel.aunPath, encryptionSeed: this.configModel.seedPassword ?? '' });
+            this._aidStore = store;
+            const loaded = await store.load(String(record.subject_aid ?? ''));
+            if (!loaded.ok || !loaded.data.aid.isPrivateKeyValid())
+                throw new StateError('ownership subject signing identity is unavailable');
+            if (!await this._agentMdManager.resumePendingUpload(String(record.subject_aid ?? ''), loaded.data.aid)) {
+                const remote = await this._agentMdManager.download(String(record.subject_aid ?? ''));
+                await this._agentMdManager.uploadAs(String(record.subject_aid ?? ''), await this._ownershipAgentMdContent(record, remote.content), loaded.data.aid);
+            }
+            record.agent_md_uploaded = true;
+            return;
+        }
+        const identity = record.subject_identity;
+        const subject = String(record.subject_aid ?? '').trim().toLowerCase();
+        const signer = await AID.create({
+            aid: String(identity.aid ?? subject).trim().toLowerCase(),
+            aunPath: this.configModel.aunPath,
+            certPem: String(identity.cert ?? '').trim(),
+            privateKeyPem: String(identity.private_key_pem ?? ''),
+            certValid: true,
+            privateKeyValid: true,
+        });
+        if (!await this._agentMdManager.resumePendingUpload(subject, signer)) {
+            const remote = await this._agentMdManager.download(subject);
+            await this._agentMdManager.uploadAs(subject, await this._ownershipAgentMdContent(record, remote.content), signer);
+        }
+        record.agent_md_uploaded = true;
+    }
+    async releaseOwnership(_subjectAid) {
+        throw new StateError('legacy ownership workflow is unsupported', { stringCode: 'unsupported_protocol' });
+    }
+    async release_ownership(subjectAid) { return await this.releaseOwnership(subjectAid); }
+    _scheduleOwnershipRelease(key) {
+        if (this._ownershipReleaseTasks.has(key))
+            return;
+        const task = this._runOwnershipRelease(key).finally(() => {
+            if (this._ownershipReleaseTasks.get(key) === task)
+                this._ownershipReleaseTasks.delete(key);
+        });
+        this._ownershipReleaseTasks.set(key, task);
+    }
+    async _runOwnershipRelease(key) {
+        const record = this._ownershipRecords.get(key);
+        if (!record || !['pending_rekey', 'pending_agent_md', 'pending_upload'].includes(String(record.release_status ?? '')))
+            return;
+        const active = !['no_identity', 'standby', 'closed'].includes(String(this._state).toLowerCase());
+        const reconnect = active && record.release_status === 'pending_rekey' && this._currentAid?.certFingerprint === record.release_old_fingerprint;
+        const options = { ...this._sessionOptions };
+        try {
+            if (reconnect)
+                await this.disconnect();
+            await this._resumeOwnershipRelease(key);
+        }
+        catch (error) {
+            record.last_error = error instanceof Error ? error.message : String(error);
+            this._ownershipRecords.set(key, record);
+            await this._persistOwnershipRecords();
+            this._clientLog.debug(`ownership release deferred: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            if (reconnect && this._state !== 'closed') {
+                try {
+                    await this._lifecycle.connect(options);
+                    await this._resumeOwnershipRelease(key);
+                }
+                catch (error) {
+                    this._clientLog.debug(`ownership release reconnect deferred: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+    }
+    _resumePendingOwnershipReleases() {
+        for (const [key, record] of this._ownershipRecords) {
+            if (['pending_rekey', 'pending_agent_md', 'pending_upload'].includes(String(record.release_status ?? '')))
+                this._scheduleOwnershipRelease(key);
+        }
+    }
+    async _resumeOwnershipRelease(key) {
+        const record = this._ownershipRecords.get(key);
+        if (!record || !['pending_rekey', 'pending_agent_md', 'pending_upload'].includes(String(record.release_status ?? '')))
+            return;
+        const subject = String(record.subject_aid ?? '').trim().toLowerCase();
+        const owner = String(record.owner_aid ?? '').trim().toLowerCase();
+        const release = record.ownership_release;
+        const store = this._aidStore;
+        if (!subject || !owner || !release || !store)
+            return;
+        const loaded = await store.load(subject);
+        if (!loaded.ok || !loaded.data)
+            throw new StateError(`ownership release could not load subject identity: ${subject}`);
+        const oldFingerprint = String(record.release_old_fingerprint ?? '');
+        if (oldFingerprint && loaded.data.aid.certFingerprint === oldFingerprint) {
+            const result = await store.rekey(subject);
+            if (!result.ok)
+                throw new StateError(`ownership release rekey failed: ${result.error.message}`);
+            const refreshed = await store.load(subject);
+            if (!refreshed.ok || !refreshed.data)
+                throw new StateError(`ownership release rekeyed identity could not be loaded: ${subject}`);
+            record.release_status = 'pending_agent_md';
+            this._ownershipRecords.set(key, record);
+            await this._persistOwnershipRecords();
+            this._state = 'no_identity';
+            this.loadIdentity(refreshed.data.aid);
+            return;
+        }
+        if (record.release_status === 'pending_rekey')
+            record.release_status = 'pending_agent_md';
+        this._ownershipRecords.set(key, record);
+        await this._persistOwnershipRecords();
+        if (this._currentAid?.certFingerprint !== loaded.data.aid.certFingerprint) {
+            this._state = 'no_identity';
+            this.loadIdentity(loaded.data.aid);
+        }
+        let payload = String(record.release_agent_md_payload ?? '');
+        if (!payload) {
+            const localContent = String(record.release_local_content ?? '');
+            let remoteContent = '';
+            try {
+                const downloaded = await this._agentMdManager.download(subject);
+                remoteContent = downloaded.content;
+                const remoteFrontmatter = validateAgentMdDocument(remoteContent, { expectedAid: subject, validateOwnership: false }).frontmatter;
+                const remoteStatus = String(downloaded.verification.ownership_status ?? '');
+                const currentRelease = remoteFrontmatter.ownership_release;
+                if (currentRelease && currentRelease.statement.proof_id === release.statement.proof_id && remoteStatus === 'released') {
+                    record.release_status = 'released';
+                    record.status = 'released';
+                    delete record.release_agent_md_payload;
+                    delete record.release_local_content;
+                    this._ownershipRecords.set(key, record);
+                    await this._persistOwnershipRecords();
+                    return;
+                }
+                const proof = remoteFrontmatter.ownership_proof;
+                if (remoteFrontmatter.owner !== owner || String(proof?.proof_id ?? '') !== String(record.proof_id ?? '') || remoteStatus !== 'complete') {
+                    throw new StateError('remote agent.md does not contain the active ownership relation being released');
+                }
+            }
+            catch (error) {
+                if (!(error instanceof NotFoundError))
+                    throw error;
+            }
+            if (!localContent && !remoteContent)
+                throw new StateError('ownership release has no local or remote agent.md to preserve');
+            const localTimestamp = Number(parseAgentMdTailSignature(localContent).fields?.timestamp ?? 0) || 0;
+            const remoteTimestamp = Number(parseAgentMdTailSignature(remoteContent).fields?.timestamp ?? 0) || 0;
+            const base = localContent && localTimestamp > remoteTimestamp ? localContent : remoteContent || localContent;
+            payload = buildOwnershipReleaseAgentMd(base, release);
+            record.release_agent_md_payload = payload;
+            record.release_status = 'pending_upload';
+            this._ownershipRecords.set(key, record);
+            await this._persistOwnershipRecords();
+            await this._agentMdManager.writeContent(subject, payload);
+        }
+        const pending = await this._agentMdManager.pendingUpload(subject);
+        const pendingRelease = pending ? validateAgentMdDocument(pending.content, { validateOwnership: false }).frontmatter.ownership_release : undefined;
+        if (pendingRelease?.statement.proof_id === release.statement.proof_id)
+            await this._agentMdManager.resumePendingUpload(subject);
+        else
+            await this._agentMdManager.upload(payload);
+        record.release_status = 'released';
+        record.status = 'released';
+        delete record.release_agent_md_payload;
+        delete record.release_local_content;
+        this._ownershipRecords.set(key, record);
+        await this._persistOwnershipRecords();
+    }
+    async bindAid(_subjectAid, _options = {}) {
+        throw new StateError('legacy ownership workflow is unsupported', { stringCode: 'unsupported_protocol' });
+    }
+    async bind_aid(subjectAid, options = {}) { return await this.bindAid(subjectAid, options); }
+    async bindOwner(_ownerAid, _options = {}) {
+        throw new StateError('legacy ownership workflow is unsupported', { stringCode: 'unsupported_protocol' });
+    }
+    async bind_owner(ownerAid, options = {}) { return await this.bindOwner(ownerAid, options); }
+    _ownershipPendingRequest(requestId) {
+        const id = String(requestId ?? '').trim();
+        for (const [key, record] of this._ownershipRecords) {
+            if (record.ownership_request_pending === true && String(record.request_id ?? '').trim() === id)
+                return [key, { ...record }];
+        }
+        throw new StateError('no pending ownership request found');
+    }
+    async acceptOwnershipRequest(operationId) {
+        return await this._ownershipV21().acceptOwnershipRequest(operationId);
+    }
+    async rejectOwnershipRequest(operationId, reason) {
+        return await this._ownershipV21().rejectOwnershipRequest(operationId, reason);
+    }
+    async _handleOwnershipMessage(message) {
+        const envelope = message && typeof message === 'object' && !Array.isArray(message) ? message : null;
+        const content = envelope && Object.hasOwn(envelope, 'payload') ? envelope.payload : message;
+        return await this._ownershipV21().receive(String(envelope?.from_aid ?? envelope?.from ?? ''), decryptedOwnershipJsonText(content) ?? content);
+    }
     get hasIdentity() {
         return this._currentAid !== null && this.state !== ConnectionState.CLOSED;
     }
@@ -1119,13 +1775,18 @@ export class AUNClient {
             },
             auth: () => this._auth,
             tokenStore: () => this._tokenStore,
-            fetchPeerCert: (target, certFingerprint) => this._fetchPeerCert(target, certFingerprint || undefined),
+            fetchPeerCert: (target, certFingerprint, signedAt) => this._fetchPeerCert(target, certFingerprint || undefined, undefined, signedAt),
+            entityOwnerResolver: (target, type) => this._resolveEntityAgentMdOwner(target, type),
+            entityIdentityGetter: (target, type) => this._freshEntityCertificate(target, type),
+            entitySignerResolver: (target, fingerprint) => this._freshEntitySigner(target, fingerprint),
         });
         this._transport = new RPCTransport({
             eventDispatcher: this._dispatcher,
             timeout: DEFAULT_SESSION_OPTIONS.timeouts.call,
         });
+        this._transport.setServiceEventVerifier((event, payload) => this._verifyIncomingServiceEvent(event, payload));
         this._transport.setProtocolDisconnectCallback((error, closeCode) => this._handleTransportDisconnect(error, closeCode));
+        this._transport._onForegroundDrained = () => this._delivery.onForegroundPullsDrained();
         this._transport.setProtocolMetaObserver((meta) => this._observeRpcMeta(meta).catch((exc) => {
             this._clientLog.debug(`rpc meta observer skipped: ${String(exc)}`);
         }));
@@ -1140,7 +1801,17 @@ export class AUNClient {
         }
     }
     loadIdentity(aid) {
+        const previousAid = this._aid;
         this._identityRuntime.loadIdentity(aid);
+        this._dispatcher.setEventIdentity(this._aid ?? '');
+        if (previousAid !== this._aid)
+            this._serviceEventIdentityVersion++;
+        this._ensureReadStateIdentity();
+        if (previousAid !== this._aid) {
+            this._ownershipRecords.clear();
+            this._ownershipType = 'agent';
+        }
+        this._ownershipRecordsLoad = this._restoreOwnershipRecords();
     }
     setProtectedHeaders(headers) {
         if (!headers) {
@@ -1187,7 +1858,7 @@ export class AUNClient {
     }
     /** 连接到 Gateway；身份来自构造函数或 loadIdentity(aid)，认证由 SDK 内部自动完成。 */
     async connect(opts) {
-        return this._lifecycle.connect(opts);
+        await this._lifecycle.connect(opts);
     }
     /** 断开连接但保留本地状态，可再次 connect */
     async disconnect() {
@@ -1205,8 +1876,13 @@ export class AUNClient {
      * 自动解密 message.pull/group.pull、Group E2EE 生命周期编排。
      */
     async call(method, params) {
+        const readIdentity = ['message.read', 'message.read_state', 'group.read', 'group.read_state'].includes(method)
+            ? this._ensureReadStateIdentity() : null;
         try {
-            return await this._rpcPipeline.call(method, params);
+            const result = await this._rpcPipeline.call(method, params);
+            if (readIdentity !== null && readIdentity === this._ensureReadStateIdentity())
+                this._observeReadStateResult(method, result, params ?? {});
+            return result;
         }
         catch (err) {
             await this._maybeHandleHalfOpenRpcFailure(err);
@@ -1262,18 +1938,36 @@ export class AUNClient {
         const target = message.slice(agentPrefix.length).trim();
         if (!target || target.toLowerCase() !== String(this._aid ?? '').trim().toLowerCase())
             return false;
-        await this._agentMdManager.upload(await this._agentMdManager.readContent(target) ?? buildDefaultAgentMd(target));
+        const content = await this._agentMdManager.readContent(target) ?? buildDefaultAgentMd(target);
+        if (!this._ordinaryAdmissionAgentMd(content, target))
+            return false;
+        await this._agentMdManager.upload(content);
         return true;
     }
+    _ordinaryAdmissionAgentMd(content, aid) {
+        const meta = validateAgentMdDocument(content, { expectedAid: aid, validateOwnership: false, checkTimestamp: false }).frontmatter;
+        return !['owner', 'ownership', 'ownership_proof', 'ownership_release'].some((field) => Object.hasOwn(meta, field));
+    }
     async _checkIdentityAdmissionAfterConnect() {
         const aid = String(this._aid ?? this._currentAid?.aid ?? '').trim();
         if (!aid)
             return;
         try {
-            const checked = await this._agentMdManager.check(aid);
-            if (!checked.remote_found) {
-                const content = await this._agentMdManager.readContent(aid) ?? buildDefaultAgentMd(aid);
-                await this._agentMdManager.upload(content);
+            const pending = await this._agentMdManager.pendingUpload(aid);
+            if (pending) {
+                if (this._ordinaryAdmissionAgentMd(pending.content, aid))
+                    await this._agentMdManager.resumePendingUpload(aid);
+            }
+            else {
+                const checked = await this._agentMdManager.check(aid, 0);
+                if (!checked.remote_found) {
+                    const content = await this._agentMdManager.readContent(aid) ?? buildDefaultAgentMd(aid);
+                    if (this._ordinaryAdmissionAgentMd(content, aid))
+                        await this._agentMdManager.upload(content);
+                }
+                else if (checked.in_sync === false) {
+                    await this._agentMdManager.download(aid);
+                }
             }
         }
         catch (exc) {
@@ -1282,6 +1976,7 @@ export class AUNClient {
         const store = this._aidStore;
         if (!store)
             return;
+        await this._resumeOrgIdentityAfterConnect(store);
         let listed;
         try {
             listed = await this.call('group.list_my', {});
@@ -1317,6 +2012,8 @@ export class AUNClient {
                         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, {}, {}, aid);
@@ -1347,6 +2044,206 @@ export class AUNClient {
                 this._groupIdentityOperations.delete(key);
         }
     }
+    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');
+        this._aidStore = store;
+        let identity = await store.load(orgAid);
+        if (!identity.ok) {
+            const registered = await store.register(orgAid, { type: 'org', owner: owner.aid });
+            if (!registered.ok)
+                throw new StateError(registered.error.message, { stringCode: 'unavailable', retryable: true });
+            identity = await store.load(orgAid);
+        }
+        if (!identity.ok)
+            throw new StateError(identity.error.message, { stringCode: 'unavailable', retryable: true });
+        const target = options.serviceAid ?? `org.${orgAid.slice(orgAid.indexOf('.') + 1)}`;
+        const tokens = store._tokenStore;
+        const inputHash = await ownershipSha256(canonicalJson(params));
+        const raw = await tokens.getMetadata(orgAid, 'org_identity_creation');
+        let checkpoint = raw ? JSON.parse(raw) : undefined;
+        if (checkpoint && (checkpoint.owner_aid !== owner.aid || checkpoint.input_hash !== inputHash))
+            throw new StateError('pending Org creation context changed', { stringCode: 'conflict', retryable: false });
+        if (!checkpoint) {
+            const prepared = await 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: structuredClone(params), prepared, phase: 'create' };
+            await tokens.setMetadata(orgAid, 'org_identity_creation', JSON.stringify(checkpoint));
+        }
+        if (checkpoint.phase === 'create') {
+            const result = await this.call('org.lifecycle.create', checkpoint.prepared);
+            checkpoint = { ...checkpoint, result, phase: 'upload' };
+            await tokens.setMetadata(orgAid, 'org_identity_creation', JSON.stringify(checkpoint));
+        }
+        await this._uploadOrgAgentMd(store, orgAid, checkpoint.source_params);
+        await tokens.setMetadata(orgAid, 'org_identity_creation', '');
+        return checkpoint.result;
+    }
+    async _resumeOrgIdentityAfterConnect(store) {
+        const keyStore = store._keystore;
+        const tokens = store._tokenStore;
+        if (typeof keyStore?.listIdentities !== 'function' || typeof tokens?.getMetadata !== 'function')
+            return;
+        for (const aid of await keyStore.listIdentities()) {
+            try {
+                const creationRaw = await tokens.getMetadata(aid, 'org_identity_creation');
+                const transferRaw = await tokens.getMetadata(aid, 'org_identity_transfer');
+                const creation = creationRaw ? JSON.parse(creationRaw) : undefined;
+                const transfer = transferRaw ? JSON.parse(transferRaw) : undefined;
+                if (creation?.owner_aid === this._aid) {
+                    await this.createOrg(creation.source_params, { aidStore: store });
+                    continue;
+                }
+                if (transfer?.owner_aid === this._aid) {
+                    await this.completeOrgTransfer(transfer.source_params, { aidStore: store });
+                    continue;
+                }
+                const pending = await 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=${String(error)}`);
+            }
+        }
+    }
+    async completeOrgTransfer(params = {}, options = {}) {
+        const store = options.aidStore;
+        const owner = this._currentAid;
+        const orgAid = String(params.org_id ?? '').trim();
+        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');
+        this._aidStore = store;
+        const localStore = store._keystore;
+        const tokenStore = store._tokenStore;
+        const inputHash = await ownershipSha256(canonicalJson(params));
+        const raw = await tokenStore.getMetadata(orgAid, 'org_identity_transfer');
+        let pending = raw ? JSON.parse(raw) : undefined;
+        if (pending && (pending.transfer_id !== transferId || pending.owner_aid !== owner.aid || pending.input_hash !== inputHash))
+            throw new StateError('pending Org transfer context changed', { stringCode: 'conflict', retryable: false });
+        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 new StateError('Org transfer requires both replacement membership bindings, terms and previous-owner credential', { stringCode: 'invalid', retryable: false });
+        }
+        const pendingKey = `org-transfer:${orgAid}:${transferId}`;
+        let keyPair = await localStore.loadPendingGroupBind(pendingKey);
+        if (!keyPair) {
+            if (pending)
+                throw new StateError('Org transfer private key checkpoint is unavailable', { stringCode: 'persistence_unavailable', retryable: false });
+            keyPair = await new CryptoProvider().generateIdentity();
+            await localStore.savePendingGroupBind(pendingKey, keyPair);
+        }
+        const target = options.serviceAid ?? `org.${orgAid.slice(orgAid.indexOf('.') + 1)}`;
+        const publicKey = arrayBufferToPem(base64ToUint8(keyPair.public_key_der_b64).buffer, 'PUBLIC KEY');
+        if (pending && pending.public_key !== publicKey)
+            throw new StateError('pending Org transfer key changed', { stringCode: 'conflict', retryable: false });
+        if (!pending) {
+            const rekey = { ...params, stage: 'rekey', public_key: publicKey, curve: 'P-256' };
+            delete rekey.new_owner;
+            delete rekey.request_binding;
+            delete rekey.client_signature;
+            pending = { transfer_id: transferId, owner_aid: owner.aid, public_key: publicKey, input_hash: inputHash, phase: 'rekey', source_params: structuredClone(params), rekey_params: await this.org.prepareRequest('org.lifecycle.transferAccept', rekey, target, owner) };
+            await tokenStore.setMetadata(orgAid, 'org_identity_transfer', JSON.stringify(pending));
+        }
+        if (pending.phase === 'rekey') {
+            const result = await this.call('org.lifecycle.transferAccept', pending.rekey_params);
+            pending = { ...pending, phase: 'finalize', rekey_result: result };
+            await tokenStore.setMetadata(orgAid, 'org_identity_transfer', JSON.stringify(pending));
+        }
+        const rekeyResult = pending.rekey_result;
+        const certPem = String(rekeyResult?.cert_pem ?? rekeyResult?.cert ?? '').trim();
+        if (!certPem)
+            throw new StateError('Org rekey response has no certificate', { stringCode: 'unavailable', retryable: true });
+        const imported = await store.importGroupIdentity(orgAid, { ...keyPair, cert_pem: certPem });
+        if (!imported.ok)
+            throw new StateError(imported.error.message, { stringCode: 'invalid', retryable: false });
+        const loaded = await store.load(orgAid);
+        if (!loaded.ok)
+            throw new StateError(loaded.error.message, { stringCode: 'unavailable', retryable: true });
+        const orgIdentity = loaded.data.aid;
+        if (!pending.finalize_params) {
+            const final = { ...pending.source_params, stage: 'finalize', public_key: publicKey, curve: 'P-256', request_id: crypto.randomUUID().replace(/-/g, ''), nonce: randomBase64Url(32) };
+            delete final.request_binding;
+            delete final.client_signature;
+            for (const field of ['previous_owner', 'new_owner']) {
+                const material = final[field];
+                let binding = material.membership_binding;
+                if (!binding.member_signature && binding.member_aid === owner.aid)
+                    binding = await signMembershipBinding(binding, owner, 'member');
+                binding = await signMembershipBinding(binding, orgIdentity, 'org');
+                const oldCredential = isJsonObject(material.credential_template) ? { ...material.credential_template } : undefined;
+                if (oldCredential) {
+                    delete oldCredential.signature;
+                    oldCredential.key_version = orgIdentity.certFingerprint;
+                }
+                const credential = oldCredential ? await createCredential(oldCredential, orgIdentity) : await createMemberCredential(binding, orgIdentity, { key_version: orgIdentity.certFingerprint });
+                final[field] = { ...material, membership_binding: binding, credential_template: credential };
+                delete final[field].registration_authorization;
+            }
+            pending = { ...pending, finalize_params: await this.org.prepareRequest('org.lifecycle.transferAccept', final, target, owner, { orgSigner: orgIdentity }) };
+            await tokenStore.setMetadata(orgAid, 'org_identity_transfer', JSON.stringify(pending));
+        }
+        const result = await this.call('org.lifecycle.transferAccept', pending.finalize_params);
+        await this._uploadOrgAgentMd(store, orgAid, pending.source_params);
+        await tokenStore.setMetadata(orgAid, 'org_identity_transfer', '');
+        await localStore.clearPendingGroupBind(pendingKey);
+        return result;
+    }
+    async dissolveOrg(params = {}, options = {}) {
+        const store = options.aidStore ?? this._aidStore;
+        if (store)
+            this._aidStore = store;
+        const orgAid = String(params.org_id ?? '').trim();
+        const owner = this._currentAid;
+        const target = options.serviceAid ?? `org.${orgAid.slice(orgAid.indexOf('.') + 1)}`;
+        const payload = owner ? await this.org.prepareRequest('org.lifecycle.dissolve', params, target, owner) : params;
+        const result = await this.call('org.lifecycle.dissolve', payload);
+        const organization = isJsonObject(result?.organization) ? result.organization : {};
+        const status = String(organization.status ?? result?.status ?? '');
+        if (store && orgAid && status === 'dissolved') {
+            const tokenStore = store._tokenStore;
+            const keyStore = store._keystore;
+            const certPem = await keyStore?.loadCert?.(orgAid);
+            const transferRaw = await tokenStore?.getMetadata?.(orgAid, 'org_identity_transfer');
+            const transfer = transferRaw ? JSON.parse(transferRaw) : undefined;
+            if (transfer?.transfer_id && typeof keyStore?.clearPendingGroupBind === 'function') {
+                await keyStore.clearPendingGroupBind(`org-transfer:${orgAid}:${String(transfer.transfer_id)}`);
+            }
+            if (certPem)
+                await tokenStore?.setMetadata?.(orgAid, 'invalidated_entity_certificate', await certificateSha256Fingerprint(certPem));
+            await tokenStore?.setMetadata?.(orgAid, 'org_identity_creation', '');
+            await tokenStore?.setMetadata?.(orgAid, 'org_identity_transfer', '');
+            await tokenStore?.saveInstanceState?.(orgAid, store.deviceId, store.slotId, {});
+            await store._agentMdManager?.saveRecord?.(orgAid, {
+                pending_operation: '', pending_content: '', pending_content_etag: '', pending_error: '',
+                pending_condition: {}, pending_relation: {}, pending_authorization: '',
+            });
+        }
+        return result;
+    }
+    async _uploadOrgAgentMd(store, orgAid, params) {
+        const owner = this._currentAid;
+        if (!owner)
+            throw new StateError('Org agent.md requires current owner', { stringCode: 'forbidden', retryable: false });
+        if (await this._resumeGroupAgentMdUpload(store, orgAid))
+            return;
+        const loaded = await store.load(orgAid);
+        if (!loaded.ok)
+            throw new StateError(loaded.error.message, { stringCode: 'unavailable', retryable: true });
+        const content = String(params.org_agent_md ?? buildDefaultAgentMd(orgAid, { type: 'org', owner: owner.aid, entityCertFingerprint: loaded.data.aid.certFingerprint, name: String(params.name ?? orgAid) }));
+        const uploaded = await store.uploadAgentMd(orgAid, content, { uploaderAid: owner.aid, entityOwnerResolver: (aid, type) => this._resolveEntityAgentMdOwner(aid, type), entityIdentityGetter: (aid) => this._freshEntityCertificate(aid, 'org'), entitySignerResolver: (aid, fingerprint) => this._freshEntitySigner(aid, fingerprint) });
+        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 new StateError(uploaded.error.message, { stringCode: code, retryable: code === 'unavailable' });
+        }
+    }
     async createGroup(params = {}, options = {}) {
         if (!isJsonObject(params)) {
             throw new ValidationError('createGroup params must be an object');
@@ -1505,7 +2402,7 @@ export class AUNClient {
         }
         return { ...(isJsonObject(result) ? result : {}), invites, invite_errors: inviteErrors };
     }
-    _groupAgentMdContent(groupAid, params = {}, group = {}) {
+    async _groupAgentMdContent(groupAid, params = {}, group = {}) {
         const explicit = params.group_agent_md ?? params.groupAgentMd ?? params.content;
         if (explicit !== undefined && explicit !== null)
             return String(explicit);
@@ -1524,27 +2421,77 @@ export class AUNClient {
             .split(/\s+/).filter(Boolean).join(' ');
         const description = Array.from(normalizedDescription).slice(0, 100).join('');
         const avatar = Array.from(value('avatar')).slice(0, 256).join('');
+        const loaded = await this._aidStore?.load(groupAid);
+        if (!loaded?.ok)
+            throw new StateError('entity local certificate is unavailable', { stringCode: 'unavailable', retryable: true });
         return [
             '---\n',
             `aid: ${JSON.stringify(groupAid)}\n`,
             `name: ${JSON.stringify(name)}\n`,
             'type: "group"\n',
             'version: "1.0.0"\n',
+            `owner: ${JSON.stringify(String(group.owner_aid ?? group.owner ?? this._aid ?? ''))}\n`,
+            `entity_cert_fingerprint: ${JSON.stringify(loaded.data.aid.certFingerprint)}\n`,
             `description: ${JSON.stringify(description)}\n`,
             ...(avatar ? [`avatar: ${JSON.stringify(avatar)}\n`] : []),
             '---\n\n',
             `# ${name}\n`,
         ].join('');
     }
+    async _resumeGroupAgentMdUpload(store, groupAid) {
+        const identityStore = store;
+        const pendingManager = identityStore._agentMdManager ?? this._agentMdManager;
+        const pending = await 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))) {
+            throw new StateError('ownership pending agent.md requires its persisted 2.1 task', { stringCode: 'unsupported_protocol' });
+        }
+        const identity = this._currentAid;
+        if (!identity || fields.owner !== identity.aid)
+            throw new StateError('group agent.md recovery requires its original current owner', { stringCode: 'forbidden' });
+        const manager = new AgentMdManager({
+            aunPath: store.aunPath,
+            tokenStore: identityStore._tokenStore,
+            uploadViaGatewayHost: true,
+            ownerAidGetter: () => identity.aid,
+            currentAidGetter: () => identity,
+            entityOwnerResolver: (aid, type) => this._resolveEntityAgentMdOwner(aid, type),
+            entityIdentityGetter: (aid, type) => this._freshEntityCertificate(aid, type),
+            entitySignerResolver: (aid, fingerprint) => this._freshEntitySigner(aid, fingerprint),
+            gatewayResolver: (aid) => identityStore._resolveGateway(aid),
+            accessTokenResolver: (_aid, gatewayUrl) => identityStore._uploadAgentMdToken(identity, gatewayUrl),
+            aidValidator: (aid) => identityStore._registerFlow.validateAidName(aid),
+        });
+        return await manager.resumePendingUpload(groupAid);
+    }
     async _uploadGroupAgentMd(store, groupAid, params, group, uploaderAid) {
+        if (await this._resumeGroupAgentMdUpload(store, groupAid))
+            return;
         if (typeof store.uploadAgentMd !== 'function') {
             throw new ValidationError('group agent.md upload is unavailable');
         }
-        const uploaded = await store.uploadAgentMd(groupAid, this._groupAgentMdContent(groupAid, params, group), { uploaderAid });
+        const uploaded = await store.uploadAgentMd(groupAid, await this._groupAgentMdContent(groupAid, params, group), { uploaderAid, entityOwnerResolver: (aid, type) => this._resolveEntityAgentMdOwner(aid, type), entityIdentityGetter: (aid, type) => this._freshEntityCertificate(aid, type), entitySignerResolver: (aid, fingerprint) => this._freshEntitySigner(aid, fingerprint) });
         if (!uploaded.ok) {
             throw new ValidationError(`group agent.md upload failed: ${uploaded.error.message}`);
         }
     }
+    async _freshEntityCertificate(aid, type = 'group') {
+        const cert = await this._auth.resolveCurrentEntityCertificate(await this._resolveOwnershipCertificateGateway(aid), aid, type);
+        return AID.create({ aid, aunPath: this.configModel.aunPath, certPem: cert.cert_pem, certValid: true, privateKeyPem: null, privateKeyValid: false });
+    }
+    async _freshEntitySigner(aid, fingerprint) {
+        const cert = await this._auth.resolveOwnershipCertificate(await this._resolveOwnershipCertificateGateway(aid), aid, fingerprint);
+        return AID.create({ aid, aunPath: this.configModel.aunPath, certPem: cert.cert_pem, certValid: true, privateKeyPem: null, privateKeyValid: false });
+    }
+    async _resolveEntityAgentMdOwner(aid, type) {
+        const authority = await this._agentMdManager.readEntityAuthorityFresh(aid);
+        const certificate = await this._freshEntityCertificate(aid, type);
+        if (authority.entity_cert_fingerprint !== certificate.certFingerprint)
+            throw new StateError('entity certificate authority changed', { stringCode: 'conflict' });
+        return authority.owner_aid;
+    }
     async bindGroupAid(params = {}, options = {}) {
         if (!isJsonObject(params)) {
             throw new ValidationError('bindGroupAid params must be an object');
@@ -2002,6 +2949,168 @@ export class AUNClient {
     on(event, handler) {
         return this._dispatcher.subscribe(event, handler);
     }
+    _readStateIsNewer(previous, current) {
+        if (!previous)
+            return true;
+        const oldOrder = BigInt(String(previous.last_read_order ?? 0));
+        const newOrder = BigInt(String(current.last_read_order ?? 0));
+        if (oldOrder !== newOrder)
+            return newOrder > oldOrder;
+        const oldId = String(previous.last_read_message_id ?? '');
+        const newId = String(current.last_read_message_id ?? '');
+        if (oldOrder === 0n)
+            return newId === oldId;
+        const oldPoints = Array.from(oldId);
+        const newPoints = Array.from(newId);
+        for (let index = 0; index < Math.min(oldPoints.length, newPoints.length); index++) {
+            const oldPoint = oldPoints[index].codePointAt(0);
+            const newPoint = newPoints[index].codePointAt(0);
+            if (oldPoint !== newPoint)
+                return newPoint > oldPoint;
+        }
+        return newPoints.length >= oldPoints.length;
+    }
+    _ensureReadStateIdentity() {
+        const identity = `${this._aid ?? ''}\u0000${this._deviceId ?? ''}`;
+        if (identity !== this._readStateIdentity) {
+            this._readStateCache.clear();
+            this._readStateQueries.clear();
+            this._readStateIdentity = identity;
+            this._readStateGeneration += 1;
+        }
+        return `${identity}\u0000${this._readStateGeneration}`;
+    }
+    _registerReadStateQuery(method, params) {
+        const key = method + '\u0000' + JSON.stringify(Object.keys(params).sort().map((field) => [field, params[field]]));
+        this._readStateQueries.set(key, { method, params: { ...params } });
+    }
+    _readStateItems(result) {
+        const resultObject = isJsonObject(result) ? result : null;
+        return Array.isArray(resultObject?.states)
+            ? resultObject.states.filter((item) => isJsonObject(item))
+            : [];
+    }
+    _observeReadStateResult(method, result, params) {
+        if (!['message.read', 'message.read_state', 'group.read', 'group.read_state'].includes(method))
+            return;
+        this._ensureReadStateIdentity();
+        const isGroup = method.startsWith('group.');
+        if (method.endsWith('.read')) {
+            for (const state of this._readStateItems(params)) {
+                const query = { topic_key: state.topic_key ?? '' };
+                if (isGroup)
+                    query.group_id = state.group_id ?? params.group_id ?? '';
+                else
+                    query.scope = state.scope || params.scope || 'p2p';
+                this._registerReadStateQuery(`${isGroup ? 'group' : 'message'}.read_state`, query);
+            }
+            if (!Array.isArray(params.states) && params.topic_key) {
+                const query = {};
+                for (const field of ['scope', 'group_id', 'topic_key']) {
+                    if (field in params)
+                        query[field] = params[field];
+                }
+                this._registerReadStateQuery(`${isGroup ? 'group' : 'message'}.read_state`, query);
+            }
+            return;
+        }
+        this._registerReadStateQuery(method, params);
+        for (const state of this._readStateItems(result)) {
+            const scope = String(state.scope ?? (isGroup ? 'group' : 'p2p')).trim();
+            const topicKey = String(state.topic_key ?? params.topic_key ?? '');
+            const groupId = isGroup ? String(state.group_id ?? params.group_id ?? '').trim() : '';
+            const lastRead = String(state.last_read_message_id ?? '').trim();
+            if (!scope || !topicKey || !lastRead || (isGroup && !groupId))
+                continue;
+            const key = `${scope}\u0000${groupId}\u0000${topicKey}`;
+            const query = { topic_key: topicKey };
+            if (isGroup)
+                query.group_id = groupId;
+            else
+                query.scope = scope;
+            const previous = this._readStateCache.get(key)?.state;
+            if (previous && !this._readStateIsNewer(previous, state))
+                continue;
+            const samePosition = previous?.last_read_message_id === state.last_read_message_id
+                && BigInt(String(previous?.last_read_order ?? 0)) === BigInt(String(state.last_read_order ?? 0));
+            this._readStateCache.set(key, {
+                method: `${isGroup ? 'group' : 'message'}.read_state`,
+                params: query,
+                state: samePosition ? { ...previous, ...state } : { ...state },
+            });
+        }
+    }
+    _onRawReadChanged(data, expectedScope) {
+        if (!isJsonObject(data))
+            return;
+        const eventData = data;
+        if (eventData.scope !== expectedScope || eventData.owner_aid !== this._aid)
+            return;
+        const fields = ['owner_aid', 'topic_key', 'last_read_message_id', ...(expectedScope === 'group' ? ['group_id'] : [])];
+        if (fields.some((field) => {
+            const value = eventData[field];
+            return typeof value !== 'string' || !value || Array.from(value).length > 128;
+        }))
+            return;
+        const order = eventData.last_read_order;
+        if (!(typeof order === 'number' && Number.isSafeInteger(order) && order > 0)
+            && !(typeof order === 'string' && /^[1-9]\d*$/.test(order)))
+            return;
+        this._ensureReadStateIdentity();
+        const scope = expectedScope;
+        const topicKey = String(eventData.topic_key ?? '');
+        const groupId = scope === 'group' ? String(eventData.group_id) : '';
+        const lastRead = String(eventData.last_read_message_id);
+        if (scope && topicKey && lastRead && (scope !== 'group' || groupId)) {
+            const key = `${scope}\u0000${groupId}\u0000${topicKey}`;
+            const query = { topic_key: topicKey };
+            if (scope === 'group')
+                query.group_id = groupId;
+            else
+                query.scope = scope;
+            const method = `${scope === 'group' ? 'group' : 'message'}.read_state`;
+            this._registerReadStateQuery(method, query);
+            const previous = this._readStateCache.get(key)?.state;
+            if (previous && (!this._readStateIsNewer(previous, eventData)
+                || (previous.last_read_message_id === eventData.last_read_message_id
+                    && BigInt(String(previous.last_read_order ?? 0)) === BigInt(String(eventData.last_read_order ?? 0)))))
+                return;
+            this._readStateCache.set(key, { method, params: query, state: { ...eventData } });
+        }
+        this._dispatcher.enqueue(scope === 'group' ? 'group.read_changed' : 'message.read_changed', eventData);
+    }
+    async _reconcileReadStates() {
+        const identity = this._ensureReadStateIdentity();
+        const keys = new Set();
+        const errors = [];
+        for (const entry of [...this._readStateQueries.values()]) {
+            try {
+                const result = await this.call(entry.method, { ...entry.params });
+                if (identity !== this._ensureReadStateIdentity())
+                    return;
+                this._observeReadStateResult(entry.method, result, entry.params);
+                for (const state of this._readStateItems(result)) {
+                    const scope = String(state.scope ?? (entry.method.startsWith('group.') ? 'group' : 'p2p'));
+                    const groupId = scope === 'group' ? String(state.group_id ?? entry.params.group_id ?? '') : '';
+                    const topicKey = String(state.topic_key ?? entry.params.topic_key ?? '');
+                    const key = `${scope}\u0000${groupId}\u0000${topicKey}`;
+                    if (this._readStateCache.has(key))
+                        keys.add(key);
+                }
+            }
+            catch (error) {
+                errors.push({ method: entry.method, params: { ...entry.params }, error: error instanceof Error ? error.message : String(error) });
+                this._clientLog.debug(`read state reconnect reconciliation failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            if (identity !== this._ensureReadStateIdentity())
+                return;
+        }
+        this._dispatcher.enqueue('read_state_sync', {
+            owner_aid: this._aid ?? '',
+            states: [...keys].map((key) => ({ ...this._readStateCache.get(key).state })),
+            errors,
+        });
+    }
     /** 取消订阅事件 */
     off(event, handler) {
         this._dispatcher.unsubscribe(event, handler);
@@ -2045,6 +3154,8 @@ export class AUNClient {
         this._delivery.markPublishedSeq(ns, seq);
     }
     async _publishAppEvent(event, payload, source = 'direct', ns = '', batch) {
+        if (event === 'message.received' && await this._handleOwnershipMessage(payload))
+            return;
         await this._delivery.publishAppEvent(event, payload, source, ns, batch);
     }
     _echoTimestamp() {
@@ -2086,8 +3197,8 @@ export class AUNClient {
         const trace = `${this._echoTimestamp()} [AUN-SDK.receive] aid=${this._aid ?? '-'} conn_uptime=${uptime}s`;
         msg.payload = { ...payload, text: payload.text + '\n' + trace };
     }
-    async _drainOrderedMessages(ns, beforeSeq, pullResponse = false, persist = true) {
-        await this._delivery.drainOrderedMessages(ns, beforeSeq, pullResponse, persist);
+    async _drainOrderedMessages(ns, beforeSeq, pullResponse = false, persist = true, throughSeq) {
+        await this._delivery.drainOrderedMessages(ns, beforeSeq, pullResponse, persist, undefined, 'pull', throughSeq);
     }
     async _publishOrderedMessage(event, ns, seq, payload, source = 'push', batch) {
         return this._delivery.publishOrderedMessage(event, ns, seq, payload, source, batch);
@@ -2546,11 +3657,26 @@ export class AUNClient {
      * 获取对方证书（带缓存 + 完整 PKI 验证：链 + CRL + OCSP + AID 绑定）。
      * 跨域时自动将请求路由到 peer 所在域的 Gateway。
      */
-    async _fetchPeerCert(aid, certFingerprint, timeoutMs = 5000) {
+    async _resolveServiceEventCertificate(aid, fingerprint) {
+        const certPem = await this._fetchPeerCert(aid, fingerprint);
+        if (!this._gatewayUrl)
+            throw new ValidationError('gateway url unavailable for service event certificate verification');
+        await this._auth.verifyPeerCertificate(resolvePeerGatewayUrl(this._gatewayUrl, aid), certPem, aid, undefined, true);
+        return certPem;
+    }
+    async _verifyIncomingServiceEvent(event, payload) {
+        const targetAid = this._aid || this._currentAid?.aid || '';
+        const version = this._serviceEventIdentityVersion;
+        const verified = await verifyServiceEvent(event, payload, { targetAid, resolveEventCertificate: (service, fingerprint) => this._resolveServiceEventCertificate(service, fingerprint), resolveCredentialService: (cid) => this.resolveCredentialService?.(cid) });
+        if (version !== this._serviceEventIdentityVersion || targetAid !== (this._aid || this._currentAid?.aid || ''))
+            throw new ValidationError('service event receiver identity changed');
+        return verified;
+    }
+    async _fetchPeerCert(aid, certFingerprint, timeoutMs = 5000, signedAt) {
         const tStart = Date.now();
         this._clientLog.debug(`_fetchPeerCert enter: aid=${aid} fingerprint=${certFingerprint ?? '<none>'}`);
         try {
-            const cacheKey = certCacheKey(aid, certFingerprint);
+            const cacheKey = certCacheKey(aid, certFingerprint) + (signedAt === undefined ? '' : `:signed:${signedAt}`);
             const cached = this._certCache.get(cacheKey);
             const now = Date.now() / 1000;
             if (cached && now < cached.refreshAfter) {
@@ -2589,7 +3715,10 @@ export class AUNClient {
             }
             // 完整 PKI 验证：链 + CRL + OCSP + AID 绑定
             try {
-                await this._auth.verifyPeerCertificate(peerGatewayUrl, certPem, aid);
+                if (signedAt === undefined)
+                    await this._auth.verifyPeerCertificate(peerGatewayUrl, certPem, aid);
+                else
+                    await this._auth.verifyPeerCertificate(peerGatewayUrl, certPem, aid, signedAt);
             }
             catch (exc) {
                 throw new ValidationError(`peer cert verification failed for ${aid}: ${exc}`);
@@ -2664,6 +3793,8 @@ export class AUNClient {
                         if (identity && isJsonObject(identity)) {
                             this._identity = identity;
                             this._aid = String(identity.aid ?? this._aid ?? '');
+                            this._ownershipRecordsLoad = this._restoreOwnershipRecords();
+                            await this._ownershipRecordsLoad;
                             this._logger.bindAid(this._aid);
                             if (this._sessionParams) {
                                 this._sessionParams.access_token = String(auth.token ?? params.access_token ?? '');
@@ -2746,6 +3877,7 @@ export class AUNClient {
             }
             this._lifecycle.assertConnectionAttemptOwner(connectionOwner);
             this._startBackgroundTasks();
+            this._safeAsync(this._reconcileReadStates());
             this._safeAsync(this.restoreGroupInvitesAfterConnect());
             const connectionKind = String(params.connection_kind ?? 'long');
             const isShortConnection = connectionKind === 'short';
@@ -2764,7 +3896,7 @@ export class AUNClient {
             if (backgroundSyncEnabled) {
                 this._safeAsync(this._fillP2pGap());
             }
-            this._safeAsync(this._checkIdentityAdmissionAfterConnect());
+            this._safeAsync(this._resumeOwnershipAfterConnect());
             this._clientLog.debug(`_connectOnce exit: elapsed=${Date.now() - tStart}ms aid=${this._aid ?? '-'}`);
         }
         catch (err) {
@@ -2783,6 +3915,23 @@ export class AUNClient {
         const gateways = await this._resolveGatewayCandidatesForAid(aid);
         return gateways[0];
     }
+    async _resolveOwnershipCertificateGateway(aid) {
+        const issuer = aid.slice(aid.indexOf('.') + 1);
+        if (issuer === this._aid?.slice(this._aid.indexOf('.') + 1))
+            return this._resolveGatewayForAid(aid);
+        let lastError;
+        for (const host of [aid, `gateway.${issuer}`]) {
+            try {
+                const gateways = await this._discovery.discoverAll(`https://${host}/.well-known/aun-gateway`);
+                if (gateways.length)
+                    return gateways[0];
+            }
+            catch (error) {
+                lastError = error;
+            }
+        }
+        throw new StateError(lastError instanceof Error ? lastError.message : 'signer Gateway discovery failed', { stringCode: 'unavailable', retryable: true });
+    }
     async _resolveGatewayCandidatesForAid(aid) {
         const target = String(aid ?? this._aid ?? '').trim();
         if (!target)
@@ -3006,6 +4155,7 @@ export class AUNClient {
     }
     // ── 内部：后台任务 ────────────────────────────────
     _startBackgroundTasks() {
+        this._startOwnershipRecovery();
         // WebSocket Ping/Pong 由 Gateway 与传输层处理；SDK 不发送 RPC 心跳。
         // 短连接生命周期短，不需要 token 刷新。
         if (this._sessionOptions?.connection_kind !== 'short') {
@@ -3034,6 +4184,11 @@ export class AUNClient {
         }
     }
     _stopBackgroundTasks() {
+        this._ownershipRecoveryGeneration += 1;
+        if (this._ownershipRecoveryTimer !== null) {
+            clearTimeout(this._ownershipRecoveryTimer);
+            this._ownershipRecoveryTimer = null;
+        }
         if (this._heartbeatTimer !== null) {
             clearInterval(this._heartbeatTimer);
             this._heartbeatTimer = null;
@@ -3047,6 +4202,32 @@ export class AUNClient {
             this._cacheCleanupTimer = null;
         }
     }
+    _startOwnershipRecovery() {
+        if (this._ownershipRecoveryTimer !== null || !this._aid || this._state !== 'connected' || this._closing || this._disconnecting)
+            return;
+        const aid = this._aid, generation = ++this._ownershipRecoveryGeneration;
+        const active = () => generation === this._ownershipRecoveryGeneration && aid === this._aid && this._state === 'connected' && !this._closing && !this._disconnecting;
+        const guard = () => { if (!active())
+            throw new StateError('ownership recovery was superseded', { stringCode: 'forbidden' }); };
+        const recover = async () => {
+            try {
+                if (!active())
+                    return;
+                await this._withBackgroundRpc(async () => {
+                    await this._resumeRegistrationIntent(guard);
+                    guard();
+                    await this._ownershipV21().resume(guard);
+                });
+            }
+            finally {
+                if (active())
+                    this._ownershipRecoveryTimer = setTimeout(() => this._safeAsync(recover()), 5000);
+                else if (generation === this._ownershipRecoveryGeneration)
+                    this._ownershipRecoveryTimer = null;
+            }
+        };
+        this._ownershipRecoveryTimer = setTimeout(() => this._safeAsync(recover()), 5000);
+    }
     /** 心跳定时器 */
     _startHeartbeat() {
         if (this._heartbeatTimer !== null) {