@agentunion/fastaun-browser 0.5.18 → 0.5.20

package/dist/agent-md.js

@@ -1,9 +1,43 @@
 import { AID } from './aid.js';
-import { certMatchesFingerprint, parseAgentMdTailSignature } from './cert-utils.js';
-import { validateAgentMdDocument, verifyAgentMdUpload } from './agent-md-schema.js';
+import { parseDocument } from 'yaml';
+import { certMatchesFingerprint, normalizeFingerprintHex, parseAgentMdTailSignature, parseAgentMdTailSignatureForRead } from './cert-utils.js';
+import { parseFileFrontmatter, validateAgentMdDocument, validateAgentMdDocumentForRead, verifyAgentMdUpload, verifyAgentMdLegacyBodyUpload } from './agent-md-schema.js';
+import { validateOwnershipFrontmatter, verifyOwnershipFrontmatterStatus } from './ownership-proof.js';
 import { AUNError, ClientSignatureError, NotFoundError, StateError, ValidationError } from './errors.js';
 import { isJsonObject } from './types.js';
+import { ownershipAid, parseOwnershipFile } from './ownership-v21.js';
 const DEFAULT_HTTP_TIMEOUT_MS = 30_000;
+export function buildOwnershipReleaseAgentMd(content, release) {
+    return updateOwnershipAgentMd(content, { ownership_release: release });
+}
+export function buildOwnershipAgentMd(content, owner, proof) {
+    return updateOwnershipAgentMd(content, { owner, ownership_proof: proof });
+}
+export function buildOwnershipAgentMdV21(content, statement) {
+    return updateOwnershipAgentMd(content, statement ? { owner: statement.owner_aid, ownership: { statement } } : {});
+}
+function updateOwnershipAgentMd(content, fields) {
+    const payload = parseAgentMdTailSignature(String(content ?? '')).payload;
+    const match = /^---(?:\r\n|\n|\r)([\s\S]*?)(?:\r\n|\n|\r)---([\s\S]*)$/.exec(payload);
+    if (!match)
+        throw new ValidationError('agent.md must start with YAML frontmatter');
+    const document = parseDocument(match[1], { uniqueKeys: true });
+    if (document.errors.length)
+        throw new ValidationError(`agent.md frontmatter is invalid: ${document.errors[0].message}`);
+    const frontmatter = document.toJS();
+    if (!frontmatter || typeof frontmatter !== 'object' || Array.isArray(frontmatter))
+        throw new ValidationError('agent.md frontmatter must be a mapping');
+    document.delete('owner');
+    document.delete('ownership_proof');
+    document.delete('ownership_release');
+    document.delete('ownership');
+    for (const [name, value] of Object.entries(fields))
+        document.set(name, value);
+    const yamlText = document.toString().replace(/\r\n/g, '\n');
+    const updated = `---\n${yamlText.endsWith('\n') ? yamlText : `${yamlText}\n`}---${match[2]}`;
+    validateAgentMdDocument(updated, { expectedAid: String(frontmatter.aid ?? '') });
+    return updated;
+}
 export function buildDefaultAgentMd(aid, options = {}) {
     const target = String(aid ?? '').trim();
     const type = String(options.type ?? 'agent').trim() || 'agent';
@@ -16,6 +50,10 @@ export function buildDefaultAgentMd(aid, options = {}) {
         `aid: ${JSON.stringify(target)}`,
         `name: ${JSON.stringify(name)}`,
         `type: ${JSON.stringify(type)}`,
+        ...(options.exttype ? [`exttype: ${JSON.stringify(options.exttype)}`] : []),
+        ...(options.owner ? [`owner: ${JSON.stringify(options.owner)}`] : []),
+        ...(options.entityCertFingerprint ? [`entity_cert_fingerprint: ${JSON.stringify(options.entityCertFingerprint)}`] : []),
+        ...(options.ownershipProof ? [`ownership_proof: ${JSON.stringify(options.ownershipProof)}`] : []),
         'version: "1.0.0"',
         `description: ${JSON.stringify(description)}`,
         ...(avatar ? [`avatar: ${JSON.stringify(avatar)}`] : []),
@@ -44,6 +82,24 @@ function nodeBuiltin(name) {
         return null;
     }
 }
+async function sha256Hex(value) {
+    const digest = await globalThis.crypto.subtle.digest('SHA-256', new TextEncoder().encode(value));
+    return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+function randomOwnerAuthorizationNonce() {
+    if (typeof globalThis.crypto.randomUUID === 'function')
+        return globalThis.crypto.randomUUID().replaceAll('-', '');
+    const bytes = new Uint8Array(16);
+    globalThis.crypto.getRandomValues(bytes);
+    return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+function base64UrlEncode(value) {
+    const bytes = new TextEncoder().encode(value);
+    let binary = '';
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return globalThis.btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+}
 function requestHeaders(init) {
     const out = {};
     try {
@@ -231,7 +287,11 @@ export class AgentMdManager {
     _gatewayResolver;
     _peerResolver;
     _accessTokenResolver;
+    _uploadAccessTokenResolver;
     _aidValidator;
+    _entityOwnerResolver;
+    _entityIdentityGetter;
+    _entitySignerResolver;
     _cache = new Map();
     _memoryStorage = new Map();
     _fetchInflight = new Set();
@@ -250,7 +310,11 @@ export class AgentMdManager {
         this._gatewayResolver = opts.gatewayResolver;
         this._peerResolver = opts.peerResolver;
         this._accessTokenResolver = opts.accessTokenResolver;
+        this._uploadAccessTokenResolver = opts.uploadAccessTokenResolver;
         this._aidValidator = opts.aidValidator;
+        this._entityOwnerResolver = opts.entityOwnerResolver;
+        this._entityIdentityGetter = opts.entityIdentityGetter;
+        this._entitySignerResolver = opts.entitySignerResolver;
     }
     get root() {
         return this._agentMdPath || this._defaultRoot();
@@ -259,6 +323,73 @@ export class AgentMdManager {
         this._aunPath = String(aunPath ?? '');
         this.setRoot(null);
     }
+    async readOwnershipFresh(aid) {
+        const target = this._safeAid(aid);
+        const gatewayUrl = await this._resolveGateway(target);
+        const viaGatewayHost = this._uploadViaGatewayHost && nodeBuiltin('node:http') !== null;
+        const headers = { 'X-AUN-Signature-Format': 'multi-v1', Accept: 'text/markdown', 'Cache-Control': 'no-cache', 'X-AUN-Ownership-Check': '1', ...(viaGatewayHost ? { Host: target } : {}) };
+        let url = this._url(target, gatewayUrl);
+        if (viaGatewayHost) {
+            const parsed = new URL(gatewayUrl);
+            const port = parsed.port && parsed.port !== '443' && parsed.port !== '20001' ? `:${parsed.port}` : '';
+            url = `${agentMdHttpScheme(gatewayUrl)}://${parsed.hostname}${port}/agent.md`;
+        }
+        const read = (targetUrl) => fetchWithTimeout(targetUrl, {
+            method: 'GET', cache: 'no-store', redirect: 'error',
+            headers,
+        });
+        let response = await read(url);
+        if (response.status === 404 && !headerValue(response.headers, 'X-AUN-Ownership-Protocol') && headerValue(response.headers, 'X-AUN-Ownership-Status') !== 'not_applicable' && viaGatewayHost) {
+            const fallback = nameServiceAgentMdUrl(target, gatewayUrl);
+            if (fallback && fallback !== url)
+                response = await read(fallback);
+        }
+        if (!response.ok && response.status !== 404)
+            throw new StateError(`NS ownership check unavailable: HTTP ${response.status}`, { stringCode: 'unavailable', retryable: true });
+        if (headerValue(response.headers, 'X-AUN-Ownership-Status') === 'not_applicable')
+            throw new StateError('group/org uses its lifecycle owner relationship', { stringCode: 'not_applicable' });
+        const protocol = headerValue(response.headers, 'X-AUN-Ownership-Protocol');
+        const version = headerValue(response.headers, 'X-AUN-Ownership-Version');
+        const lock = headerValue(response.headers, 'X-AUN-Ownership-Lock');
+        const etag = headerValue(response.headers, 'ETag');
+        if (protocol !== '2.1')
+            throw new StateError('NS ownership protocol metadata unavailable', { stringCode: 'unsupported_protocol', retryable: true });
+        if (!/^(0|[1-9][0-9]*)$/.test(version) || !Number.isSafeInteger(Number(version)) || !['locked', 'unlocked'].includes(lock))
+            throw new StateError('NS ownership relationship metadata unavailable', { stringCode: 'unavailable', retryable: true });
+        if (response.status === 404 && (Number(version) !== 0 || lock !== 'unlocked') || response.ok && !etag)
+            throw new StateError('NS ownership document metadata unavailable', { stringCode: 'unavailable', retryable: true });
+        let content = '';
+        if (response.ok) {
+            try {
+                content = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(await response.arrayBuffer());
+            }
+            catch {
+                throw new ValidationError('NS ownership file must be valid UTF-8', { stringCode: 'invalid' });
+            }
+        }
+        return { sub_aid: target, exists: response.ok, content, etag, protocol, relation_version: Number(version), lock: lock, observed_at: Math.trunc(Date.now() / 1000) };
+    }
+    async submitOwnershipRaw(aid, content, condition) {
+        const target = this._safeAid(aid);
+        if (this._currentAid()?.aid !== target)
+            throw new ValidationError('ownership upload requires its own identity', { stringCode: 'forbidden' });
+        parseOwnershipFile(content, 'agent', { expectedSubAid: target });
+        if (Boolean(condition.if_match) === Boolean(condition.if_none_match === '*'))
+            throw new ValidationError('ownership upload requires its original document condition');
+        const gatewayUrl = await this._resolveGateway(target);
+        const token = await this._uploadAccessToken(target, gatewayUrl);
+        const response = await fetchWithTimeout(this._url(target, gatewayUrl), {
+            method: 'PUT', cache: 'no-store', redirect: 'error', body: content,
+            headers: { 'X-AUN-Signature-Format': 'multi-v1', 'Content-Type': 'text/markdown; charset=utf-8', Authorization: `Bearer ${token}`,
+                ...(condition.if_match ? { 'If-Match': condition.if_match } : { 'If-None-Match': '*' }) },
+        });
+        if (!response.ok) {
+            const reason = (await response.text()).trim();
+            const code = response.status === 409 || response.status === 412 ? 'conflict' : response.status === 401 || response.status === 403 ? 'forbidden' : response.status === 428 ? 'unsupported_protocol' : response.status >= 500 ? 'unavailable' : 'invalid';
+            throw new StateError(`ownership agent.md upload failed: HTTP ${response.status}${reason ? ` ${reason}` : ''}`, { stringCode: /owner_locked/.test(reason) ? 'owner_locked' : code, retryable: code === 'unavailable' });
+        }
+        return await this.readOwnershipFresh(target);
+    }
     setRoot(root) {
         this._agentMdPath = String(root ?? '').trim() || this._defaultRoot();
         this._storageGeneration += 1;
@@ -268,7 +399,7 @@ export class AgentMdManager {
         this._snapshotLoads.clear();
         return this._agentMdPath;
     }
-    async upload(content, ownerOperationId) {
+    async upload(content) {
         const target = this._ownerAid();
         const current = this._currentAid();
         if (!target || !current) {
@@ -277,59 +408,502 @@ export class AgentMdManager {
         if (!current.isPrivateKeyValid()) {
             throw new StateError('uploadAgentMd requires loaded AID with a valid private key');
         }
-        if (content !== undefined && content !== null) {
-            const text = String(content ?? '');
-            if (text.length === 0)
-                throw new ValidationError('uploadAgentMd requires non-empty content');
-            validateAgentMdDocument(text, { expectedAid: target });
-            await this.saveRecord(target, {
-                content: text,
-                local_etag: await AgentMdManager.contentEtag(text),
-                fetched_at: Date.now(),
-            });
-        }
-        const localContent = await this.readContent(target);
+        const localContent = content ?? (String((await this.loadRecord(target, true))?.local_draft_content ?? '') || await this.readContent(target));
         if (localContent === null || localContent.length === 0) {
             throw new ValidationError('uploadAgentMd requires local agent.md content');
         }
-        validateAgentMdDocument(localContent, { expectedAid: target });
-        const signedResult = await current.signAgentMd(localContent);
+        const parsed = this._parseBodyUpdate(localContent, target);
+        if (['group', 'org'].includes(String(parsed.frontmatter.type)))
+            return await this.uploadAs(target, localContent, current);
+        if (parsed.signatures.length > 1) {
+            await this._verifyBodyUpload(target, localContent, current);
+            return await this._uploadPrepared(target, localContent, current);
+        }
+        const signedResult = await current.signAgentMd(this._isLegacyBodyRelation(parsed.frontmatter) ? parsed.payload : localContent);
         if (!signedResult.ok) {
             throw new ClientSignatureError(signedResult.error.message || 'agent.md signing failed');
         }
         const signed = signedResult.data.signed;
-        await verifyAgentMdUpload(signed, current.certPem, target);
-        const result = await this._uploadHttp(target, signed, ownerOperationId);
-        const localEtag = await AgentMdManager.contentEtag(signed);
-        const remoteEtag = String(result.etag ?? '').trim();
-        await this.saveRecord(target, {
-            content: signed,
-            local_etag: localEtag,
-            remote_etag: remoteEtag || undefined,
-            last_modified: String(result.last_modified ?? result.lastModified ?? '').trim(),
-            fetched_at: Date.now(),
-            checked_at: Date.now(),
-            remote_status: remoteEtag ? 'found' : 'unknown',
-            last_error: '',
+        await this._verifyBodyUpload(target, signed, current);
+        return await this._uploadPrepared(target, signed, current);
+    }
+    async uploadAs(targetAid, content, signer) {
+        const target = this._safeAid(String(targetAid ?? '').trim());
+        const rawContent = String(content ?? '');
+        if (!rawContent.trim())
+            throw new ValidationError('uploadAgentMd requires non-empty content');
+        const parsed = this._parseBodyUpdate(rawContent, target);
+        if (!['group', 'org'].includes(String(parsed.frontmatter.type)) && parsed.signatures.length > 1) {
+            await this._verifyBodyUpload(target, rawContent, signer);
+            return await this._uploadPrepared(target, rawContent, signer);
+        }
+        if (['group', 'org'].includes(String(parsed.frontmatter.type)) && parsed.signature) {
+            await verifyAgentMdUpload(rawContent, signer.certPem, target, undefined, async (aid, fingerprint) => {
+                if (!this._entitySignerResolver)
+                    throw new StateError('entity additional signing certificate resolver is unavailable', { stringCode: 'unavailable', retryable: true });
+                return await this._entitySignerResolver(aid, fingerprint);
+            });
+            return await this._uploadPrepared(target, rawContent, signer);
+        }
+        if (['group', 'org'].includes(String(parsed.frontmatter.type)) && signer.aid !== target) {
+            if (!this._entityIdentityGetter)
+                throw new StateError('entity signing identity is unavailable');
+            signer = await this._entityIdentityGetter(target, String(parsed.frontmatter.type));
+            if (signer.aid !== target)
+                throw new StateError('entity signing identity does not match target');
+        }
+        if (!signer?.isPrivateKeyValid())
+            throw new StateError('uploadAgentMd requires a valid signer identity');
+        const signedResult = await signer.signAgentMd(this._isLegacyBodyRelation(parsed.frontmatter) ? parsed.payload : rawContent);
+        if (!signedResult.ok)
+            throw new ClientSignatureError(signedResult.error.message || 'agent.md signing failed');
+        const signed = signedResult.data.signed;
+        await this._verifyBodyUpload(target, signed, signer);
+        return await this._uploadPrepared(target, signed, signer);
+    }
+    async pendingUpload(aid) {
+        const record = await this.loadRecord(aid);
+        if (record?.pending_operation !== 'replace' || !String(record.pending_content ?? '').trim())
+            return null;
+        return { content: String(record.pending_content), content_etag: String(record.pending_content_etag ?? ''), last_error: String(record.pending_error ?? ''), condition: record.pending_condition, relation: record.pending_relation, authorization: record.pending_authorization };
+    }
+    async resumePendingUpload(aid, signer) {
+        const pending = await this.pendingUpload(aid);
+        if (!pending)
+            return false;
+        const condition = pending.condition;
+        if (!condition || Object.keys(condition).length !== 1 || !(typeof condition.if_match === 'string' && condition.if_match || condition.if_none_match === '*'))
+            throw new StateError('pending agent.md requires its original document condition', { stringCode: 'persistence_unavailable' });
+        const pendingDocument = validateAgentMdDocument(pending.content, { expectedAid: aid, validateOwnership: false });
+        const meta = pendingDocument.frontmatter;
+        if (this._isLegacyBodyRelation(meta) && pending.relation?.protocol !== 'legacy')
+            throw new StateError('legacy ownership pending agent.md requires its original relationship snapshot', { stringCode: 'unsupported_protocol' });
+        try {
+            if (pending.relation?.protocol === 'legacy') {
+                const relation = pending.relation;
+                if (!condition.if_match || condition.if_match !== relation.original_etag || typeof relation.original_content !== 'string' || relation.original_content_etag !== await AgentMdManager.contentEtag(relation.original_content) || pending.content_etag !== await AgentMdManager.contentEtag(pending.content))
+                    throw new StateError('pending legacy original bytes or document condition are corrupt', { stringCode: 'persistence_unavailable' });
+                const original = await this._verifyLegacyBodyOriginal(aid, relation.original_content);
+                if (!this._isLegacyBodyRelation(original) || !this._sameBodyRelation(this._bodyRelationFields(original), relation.fields))
+                    throw new StateError('pending legacy original relationship snapshot is corrupt', { stringCode: 'persistence_unavailable' });
+                if (!this._sameBodyRelation(this._bodyRelationFields(meta), relation.fields))
+                    throw new StateError('legacy relationship changes require their original protocol', { stringCode: 'unsupported_protocol' });
+                const identity = signer ?? this._currentAid();
+                if (!identity || identity.aid.toLowerCase() !== aid.toLowerCase() || this._currentAid()?.aid.toLowerCase() !== aid.toLowerCase())
+                    throw new StateError('legacy body recovery requires its current subject identity', { stringCode: 'forbidden' });
+                await this._verifyBodyUpload(aid, pending.content, identity);
+                const remote = await this._readLegacyBodyFresh(aid);
+                if (remote.content === pending.content && remote.etag === pending.content_etag) {
+                    await this.saveRecord(aid, { content: pending.content, remote_etag: remote.etag, local_draft_content: '', pending_operation: '', pending_content: '', pending_content_etag: '', pending_error: '', pending_condition: {}, pending_relation: {}, pending_authorization: '' });
+                    return true;
+                }
+                if (remote.etag !== condition.if_match || remote.content !== relation.original_content)
+                    throw new StateError('pending legacy original document changed', { stringCode: 'conflict' });
+                await this._uploadPrepared(aid, pending.content, identity, condition);
+                return true;
+            }
+            if (['group', 'org'].includes(String(meta.type))) {
+                const identity = signer ?? this._currentAid();
+                if (!identity)
+                    throw new StateError('entity upload recovery requires current owner', { stringCode: 'forbidden' });
+                const context = await this._entityContext(aid, meta, identity);
+                if (!pending.relation?.entity_cert_fingerprint)
+                    throw new StateError('pending entity upload requires original owner and certificate context', { stringCode: 'persistence_unavailable' });
+                if (pending.relation.owner_aid !== context.owner_aid)
+                    throw new StateError('pending entity upload belongs to a different owner', { stringCode: 'forbidden' });
+                if (pending.relation.entity_cert_fingerprint !== context.entity_cert_fingerprint)
+                    throw new StateError('pending entity upload belongs to an old rekey generation', { stringCode: 'conflict' });
+                if (pending.content_etag !== await AgentMdManager.contentEtag(pending.content))
+                    throw new StateError('pending entity original bytes are corrupt', { stringCode: 'persistence_unavailable' });
+                const documentSigner = await this._entityDocumentSigner(aid, pending.content);
+                await this._verifyEntityDocument(aid, pending.content);
+                const remote = await this._readEntityFresh(aid);
+                if (remote.exists && remote.content === pending.content && remote.etag === pending.content_etag) {
+                    await this.saveRecord(aid, { content: pending.content, remote_etag: remote.etag, local_draft_content: '', pending_operation: '', pending_content: '', pending_content_etag: '', pending_error: '', pending_condition: {}, pending_relation: {}, pending_authorization: '' });
+                    return true;
+                }
+                if (condition.if_match && (!remote.exists || remote.etag !== condition.if_match) || condition.if_none_match === '*' && remote.exists)
+                    throw new StateError('pending agent.md original document condition changed', { stringCode: 'conflict' });
+                await this._uploadPrepared(aid, pending.content, identity, condition);
+                return true;
+            }
+            const identity = signer ?? this._currentAid();
+            if (pendingDocument.signatures.length > 1) {
+                if (!identity)
+                    throw new StateError('pending agent.md requires a signer identity');
+                await this._verifyBodyUpload(aid, pending.content, identity);
+            }
+            const remote = await this.readOwnershipFresh(aid);
+            const fail = (code, reason, retryable = false) => new StateError(reason, { stringCode: code, retryable });
+            const candidate = parseOwnershipFile(pending.content, 'agent', { expectedSubAid: aid });
+            const relation = pending.relation && Object.keys(pending.relation).length ? pending.relation : undefined;
+            const sameStatement = (first, second) => first == null && second == null || isJsonObject(first) && isJsonObject(second) && ['version', 'declaration_id', 'owner_aid', 'sub_aid', 'relation_version', 'declared_at'].every((field) => first[field] === second[field]);
+            if (candidate.statement && !relation)
+                throw fail('persistence_unavailable', 'pending ownership body update requires its original relationship context');
+            if (relation) {
+                if (remote.relation_version !== relation.relation_version || remote.lock !== relation.lock)
+                    throw fail('conflict', 'pending agent.md original relationship changed');
+                if (!sameStatement(candidate.statement, relation.statement))
+                    throw fail('unsupported_protocol', 'ownership changes require their persisted 2.1 task');
+                if (remote.exists && (remote.relation_version > 0 || candidate.statement)) {
+                    const current = parseOwnershipFile(remote.content, 'agent', { expectedSubAid: aid });
+                    if (!sameStatement(current.statement, relation.statement) || (remote.owner_aid ?? current.statement?.owner_aid ?? null) !== relation.owner_aid)
+                        throw fail('conflict', 'pending agent.md relationship statement changed');
+                }
+            }
+            if (!relation && (remote.relation_version !== 0 || remote.lock !== 'unlocked'))
+                throw fail('unavailable', 'pending agent.md cannot overwrite relationship history', true);
+            if (remote.exists && remote.etag === pending.content_etag && remote.content === pending.content) {
+                const saved = await this.saveRecord(aid, { content: pending.content, remote_etag: remote.etag, local_draft_content: '', pending_operation: '', pending_content: '', pending_content_etag: '', pending_error: '', pending_condition: {}, pending_relation: {}, pending_authorization: '' });
+                if (!saved.aid)
+                    throw new StateError('agent.md pending completion persistence failed');
+                return true;
+            }
+            if (condition.if_match && (!remote.exists || remote.etag !== condition.if_match) || condition.if_none_match === '*' && remote.exists)
+                throw new StateError('pending agent.md original document condition changed', { stringCode: 'conflict' });
+            if (!identity)
+                throw new StateError('pending agent.md requires a signer identity');
+            if (pendingDocument.signatures.length <= 1)
+                await this._verifyBodyUpload(aid, pending.content, identity);
+            await this._uploadPrepared(aid, pending.content, identity, condition);
+            return true;
+        }
+        catch (error) {
+            await this.saveRecord(aid, { pending_error: error instanceof Error ? error.message : String(error) });
+            throw error;
+        }
+    }
+    _parseBodyUpdate(content, target) {
+        const parsed = validateAgentMdDocumentForRead(content, { expectedAid: target, validateOwnership: false });
+        return validateAgentMdDocument(this._isLegacyBodyRelation(parsed.frontmatter) && parsed.signatures.length <= 1 ? parsed.payload : content, { expectedAid: target, validateOwnership: false });
+    }
+    _isLegacyBodyRelation(meta) {
+        if (['group', 'org'].includes(String(meta.type)))
+            return false;
+        if (Object.hasOwn(meta, 'ownership')) {
+            const ownership = meta.ownership;
+            const statement = isJsonObject(ownership) ? ownership.statement : undefined;
+            return isJsonObject(statement) && statement.version === 2 && !Object.hasOwn(statement, 'relation_version');
+        }
+        return ['owner', 'ownership_proof', 'ownership_release'].some((field) => Object.hasOwn(meta, field));
+    }
+    _bodyRelationFields(meta) {
+        return Object.fromEntries(['owner', 'ownership', 'ownership_proof', 'ownership_release'].filter((field) => Object.hasOwn(meta, field)).map((field) => [field, meta[field]]));
+    }
+    _sameBodyRelation(first, second) {
+        const stable = (value) => Array.isArray(value) ? value.map(stable) : isJsonObject(value) ? Object.fromEntries(Object.keys(value).sort().map((key) => [key, stable(value[key])])) : value;
+        return JSON.stringify(stable(first)) === JSON.stringify(stable(second));
+    }
+    async _readLegacyBodyFresh(target) {
+        const gateway = await this._resolveGateway(target);
+        const response = await fetchWithTimeout(this._url(target, gateway), { method: 'GET', headers: { 'X-AUN-Signature-Format': 'multi-v1', Accept: 'text/markdown', 'Cache-Control': 'no-cache' }, cache: 'no-store', redirect: 'error' });
+        if (response.status === 404)
+            throw new StateError('legacy relationship cannot be created by an ordinary body update', { stringCode: 'unsupported_protocol' });
+        const etag = headerValue(response.headers, 'ETag');
+        if (response.status !== 200 || !etag)
+            throw new StateError('legacy original document or ETag is unavailable', { stringCode: 'unavailable', retryable: true });
+        let content;
+        try {
+            content = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(await response.arrayBuffer());
+        }
+        catch {
+            throw new ValidationError('agent.md must be valid UTF-8', { stringCode: 'invalid' });
+        }
+        return { content, etag, last_modified: headerValue(response.headers, 'Last-Modified'), status: response.status };
+    }
+    async _verifyLegacyBodyOriginal(target, content) {
+        const parsed = validateAgentMdDocumentForRead(content, { expectedAid: target, validateOwnership: false, requireSignature: true });
+        const peer = await this._resolvePeer(target, parsed.signature.cert_fingerprint, Number(parsed.signature.timestamp));
+        const verified = await this._verifyPeerDocument(peer, content);
+        if (!verified.ok || verified.data.status !== 'verified')
+            throw new ClientSignatureError('legacy original agent.md signature verification failed', { stringCode: 'invalid' });
+        return parsed.frontmatter;
+    }
+    async _verifyPeerDocument(peer, content) {
+        const parsed = parseAgentMdTailSignatureForRead(content);
+        const additionalCertificates = new Map();
+        if (parsed.fields)
+            additionalCertificates.set(`${parsed.fields.signer_aid ?? peer.aid};${parsed.fields.cert_fingerprint}`, peer);
+        for (const block of parsed.signatures.slice(1))
+            additionalCertificates.set(`${block.fields.signer_aid};${block.fields.cert_fingerprint}`, await this._resolvePeer(block.fields.signer_aid, block.fields.cert_fingerprint, Number(block.fields.timestamp)));
+        return await peer.verifyAgentMd(content, (signer, fingerprint) => {
+            const certificate = additionalCertificates.get(`${signer};${fingerprint}`);
+            if (!certificate)
+                throw new StateError('additional signing certificate is unavailable', { stringCode: 'unavailable', retryable: true });
+            return certificate;
+        });
+    }
+    async _verifyBodyUpload(target, content, signer) {
+        const meta = validateAgentMdDocument(content, { expectedAid: target, validateOwnership: false }).frontmatter;
+        await (this._isLegacyBodyRelation(meta) ? verifyAgentMdLegacyBodyUpload : verifyAgentMdUpload)(content, signer.certPem, target, undefined, async (aid, fingerprint, timestamp) => {
+            if (this._entitySignerResolver)
+                return await this._entitySignerResolver(aid, fingerprint);
+            return await this._resolvePeer(aid, fingerprint, timestamp);
+        });
+    }
+    async _uploadPrepared(target, signed, signer, originalCondition) {
+        const meta = validateAgentMdDocument(signed, { expectedAid: target, validateOwnership: false }).frontmatter;
+        if (this._isLegacyBodyRelation(meta))
+            validateOwnershipFrontmatter(Object.fromEntries(['aid', 'type', 'owner'].filter((field) => Object.hasOwn(meta, field)).map((field) => [field, meta[field]])), target);
+        if (!['group', 'org'].includes(String(meta.type)))
+            await this._verifyBodyUpload(target, signed, signer);
+        if (!originalCondition) {
+            const draft = await this.saveRecord(target, { local_draft_content: signed });
+            if (draft.local_draft_content !== signed)
+                throw new StateError('agent.md local draft persistence failed', { stringCode: 'persistence_unavailable' });
+        }
+        const entity = ['group', 'org'].includes(String(meta.type));
+        const uploader = entity ? this._currentAid() ?? signer : signer;
+        const entityContext = entity ? await this._entityContext(target, meta, uploader) : undefined;
+        if (entity)
+            await this._verifyEntityDocument(target, signed);
+        let condition = originalCondition;
+        let relation = entityContext ?? (await this.pendingUpload(target))?.relation;
+        if (!condition) {
+            let fresh;
+            if (!entity && this._isLegacyBodyRelation(meta))
+                fresh = await this._readLegacyBodyFresh(target);
+            else {
+                try {
+                    fresh = entity ? await this._readEntityFresh(target) : await this.readOwnershipFresh(target);
+                }
+                catch (error) {
+                    if (entity || !['unavailable', 'unsupported_protocol'].includes(String(error?.stringCode)))
+                        throw error;
+                    const legacy = await this._readLegacyBodyFresh(target);
+                    const legacyMeta = validateAgentMdDocumentForRead(legacy.content, { expectedAid: target, validateOwnership: false }).frontmatter;
+                    if (!this._isLegacyBodyRelation(legacyMeta))
+                        throw error;
+                    fresh = legacy;
+                }
+            }
+            const freshMeta = !entity && (!('exists' in fresh) || fresh.exists) && fresh.content ? validateAgentMdDocumentForRead(fresh.content, { expectedAid: target, validateOwnership: false }).frontmatter : undefined;
+            const legacy = !entity && (this._isLegacyBodyRelation(meta) || freshMeta && this._isLegacyBodyRelation(freshMeta));
+            if (legacy) {
+                if (!freshMeta || !this._isLegacyBodyRelation(freshMeta) || !this._sameBodyRelation(this._bodyRelationFields(meta), this._bodyRelationFields(freshMeta)))
+                    throw new StateError('legacy relationship changes require their original protocol', { stringCode: 'unsupported_protocol' });
+                if (!fresh.etag)
+                    throw new StateError('legacy original document ETag is unavailable', { stringCode: 'unavailable', retryable: true });
+                await this._verifyLegacyBodyOriginal(target, fresh.content);
+                condition = { if_match: fresh.etag };
+                relation = { protocol: 'legacy', original_content: fresh.content, original_content_etag: await AgentMdManager.contentEtag(fresh.content), original_etag: fresh.etag, fields: this._bodyRelationFields(freshMeta) };
+            }
+            else {
+                const authority = fresh;
+                condition = authority.exists ? { if_match: fresh.etag } : { if_none_match: '*' };
+                if (!entity) {
+                    const candidate = parseOwnershipFile(signed, 'agent', { expectedSubAid: target });
+                    const statement = authority.exists && (authority.relation_version > 0 || candidate.statement) ? parseOwnershipFile(fresh.content, 'agent', { expectedSubAid: target }).statement : undefined;
+                    relation = { relation_version: authority.relation_version, lock: authority.lock, owner_aid: authority.owner_aid ?? statement?.owner_aid ?? null, statement: statement ?? null };
+                }
+            }
+        }
+        if (relation?.protocol === 'legacy') {
+            if (signer.aid.toLowerCase() !== target.toLowerCase() || this._currentAid()?.aid.toLowerCase() !== target.toLowerCase() || this._currentAid()?.certFingerprint !== signer.certFingerprint)
+                throw new StateError('legacy body update requires its current subject identity', { stringCode: 'forbidden' });
+            if (!this._isLegacyBodyRelation(meta) || !this._sameBodyRelation(this._bodyRelationFields(meta), relation.fields))
+                throw new StateError('legacy relationship changes require their original protocol', { stringCode: 'unsupported_protocol' });
+            await this._verifyBodyUpload(target, signed, signer);
+        }
+        const entityAuthorization = '';
+        const pending = await this.saveRecord(target, { pending_operation: 'replace', pending_target_aid: target, pending_content: signed, pending_content_etag: await AgentMdManager.contentEtag(signed), pending_error: '', pending_condition: condition, pending_relation: relation, pending_authorization: entityAuthorization });
+        if (relation?.protocol === 'legacy' && !this._sameBodyRelation(pending.pending_relation, relation))
+            throw new StateError('legacy original relationship snapshot persistence failed', { stringCode: 'persistence_unavailable' });
+        const savedCondition = pending.pending_condition;
+        if (pending.pending_content !== signed || savedCondition?.if_match !== condition.if_match || savedCondition?.if_none_match !== condition.if_none_match || pending.pending_authorization !== entityAuthorization)
+            throw new StateError('agent.md pending upload persistence failed');
+        try {
+            const owner = this._currentAid();
+            const delegated = target.toLowerCase() !== this._ownerAid().toLowerCase();
+            if (delegated && !owner?.isPrivateKeyValid())
+                throw new StateError('owner agent.md upload requires a loaded owner identity');
+            const authorization = entity ? '' : delegated ? await this._ownerUploadAuthorization(target, signed, owner) : '';
+            const result = await this._uploadHttp(target, signed, authorization, condition, relation?.protocol === 'legacy');
+            const remoteEtag = String(result.etag ?? '').trim();
+            const contentEtag = await AgentMdManager.contentEtag(signed);
+            const saved = await this.saveRecord(target, {
+                content: signed, local_etag: contentEtag, remote_etag: remoteEtag || undefined, ...(remoteEtag === contentEtag ? { local_draft_content: '' } : {}),
+                last_modified: String(result.last_modified ?? result.lastModified ?? '').trim(), fetched_at: Date.now(), checked_at: Date.now(),
+                remote_status: remoteEtag ? 'found' : 'unknown', last_error: '',
+                pending_operation: '', pending_content: '', pending_content_etag: '', pending_error: '', pending_condition: {}, pending_relation: {}, pending_authorization: '',
+            });
+            if (!saved.aid)
+                throw new StateError('agent.md upload completion persistence failed');
+            return { ...result };
+        }
+        catch (error) {
+            await this.saveRecord(target, { pending_error: error instanceof Error ? error.message : String(error) });
+            throw error;
+        }
+    }
+    async readEntityAuthorityFresh(target) {
+        const fresh = await this._readEntityFresh(this._safeAid(target));
+        if (fresh.ownership_status !== 'not_applicable' || !['current', 'stale'].includes(fresh.entity_status ?? '') || !fresh.owner_aid || !/^sha256:[0-9a-f]{64}$/.test(fresh.entity_cert_fingerprint ?? ''))
+            throw new StateError('entity current owner authority is unavailable', { stringCode: 'unavailable', retryable: true });
+        try {
+            return { owner_aid: this._safeAid(ownershipAid(fresh.owner_aid, 'owner_aid')), entity_cert_fingerprint: fresh.entity_cert_fingerprint };
+        }
+        catch {
+            throw new StateError('entity current owner authority is unavailable', { stringCode: 'unavailable', retryable: true });
+        }
+    }
+    async _readEntityFresh(target) {
+        const gateway = await this._resolveGateway(target);
+        const viaGatewayHost = this._uploadViaGatewayHost && nodeBuiltin('node:http') !== null;
+        const headers = { 'X-AUN-Signature-Format': 'multi-v1', 'X-AUN-Ownership-Check': '1', 'Cache-Control': 'no-cache', ...(viaGatewayHost ? { Host: target } : {}) };
+        let url = this._url(target, gateway);
+        if (viaGatewayHost) {
+            const parsed = new URL(gateway);
+            const port = parsed.port && parsed.port !== '443' && parsed.port !== '20001' ? `:${parsed.port}` : '';
+            url = `${agentMdHttpScheme(gateway)}://${parsed.hostname}${port}/agent.md`;
+        }
+        let response;
+        try {
+            response = await fetchWithTimeout(url, { method: 'GET', cache: 'no-store', redirect: 'error', headers });
+        }
+        catch (error) {
+            throw new StateError(`entity agent.md fresh read unavailable: ${String(error)}`, { stringCode: 'unavailable', retryable: true });
+        }
+        if (response.status !== 200 && response.status !== 404)
+            throw new StateError(`entity agent.md fresh read failed: HTTP ${response.status}`, { stringCode: 'unavailable', retryable: true });
+        const etag = headerValue(response.headers, 'ETag');
+        if (response.status === 200 && !etag)
+            throw new StateError('entity agent.md fresh read has no ETag', { stringCode: 'unavailable', retryable: true });
+        let content = '';
+        if (response.status === 200) {
+            try {
+                content = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(await response.arrayBuffer());
+            }
+            catch {
+                throw new ValidationError('entity agent.md must be valid UTF-8', { stringCode: 'invalid' });
+            }
+        }
+        const facts = {};
+        for (const [field, header] of [['ownership_status', 'X-AUN-Ownership-Status'], ['entity_status', 'X-AUN-Entity-Verification-Status'], ['owner_aid', 'X-AUN-Entity-Owner-AID'], ['entity_cert_fingerprint', 'X-AUN-Entity-Cert-Fingerprint']]) {
+            const value = headerValue(response.headers, header);
+            if (value)
+                facts[field] = value;
+        }
+        return { exists: response.status === 200, content, etag, ...facts };
+    }
+    async _entityCurrentContext(target, meta, uploading = false) {
+        const owner = String(meta.owner ?? '').trim().toLowerCase();
+        if (!this._entityOwnerResolver)
+            throw new StateError('entity owner resolver is unavailable', { stringCode: 'unavailable', retryable: true });
+        const freshOwner = String(await this._entityOwnerResolver(target, String(meta.type))).trim().toLowerCase();
+        if (!freshOwner)
+            throw new StateError('entity current owner is unavailable', { stringCode: 'unavailable', retryable: true });
+        if (freshOwner !== owner)
+            throw new StateError('entity current owner changed', { stringCode: uploading ? 'forbidden' : 'conflict' });
+        if (!this._entityIdentityGetter)
+            throw new StateError('entity current certificate resolver is unavailable', { stringCode: 'unavailable', retryable: true });
+        const entity = await this._entityIdentityGetter(target, String(meta.type));
+        if (!entity.certFingerprint)
+            throw new StateError('entity current certificate is unavailable', { stringCode: 'unavailable', retryable: true });
+        if (meta.entity_cert_fingerprint !== entity.certFingerprint)
+            throw new StateError('entity agent.md certificate generation changed', { stringCode: 'conflict' });
+        return { type: meta.type, owner_aid: owner, entity_cert_fingerprint: entity.certFingerprint };
+    }
+    async _entityContext(target, meta, signer) {
+        const owner = String(meta.owner ?? '').trim().toLowerCase();
+        if (signer.aid.toLowerCase() !== owner || signer.aid.toLowerCase() !== this._ownerAid().toLowerCase())
+            throw new StateError('group/org agent.md requires current owner uploader', { stringCode: 'forbidden' });
+        const context = await this._entityCurrentContext(target, meta, true);
+        if (signer.aid.toLowerCase() === owner)
+            await this._verifyEntityOwnerSigner(signer);
+        else if (signer.certFingerprint !== context.entity_cert_fingerprint)
+            throw new StateError('entity uploader certificate generation changed', { stringCode: 'conflict' });
+        return context;
+    }
+    async _entityDocumentSigner(target, content) {
+        const parsed = validateAgentMdDocument(content, { expectedAid: target, requireSignature: true });
+        const signerAid = parsed.signature.signer_aid ?? target;
+        let signer;
+        if (signerAid.toLowerCase() === target.toLowerCase()) {
+            if (!this._entityIdentityGetter)
+                throw new StateError('entity current certificate resolver is unavailable', { stringCode: 'unavailable', retryable: true });
+            signer = await this._entityIdentityGetter(target, String(parsed.frontmatter.type));
+        }
+        else {
+            if (!this._entitySignerResolver)
+                throw new StateError('entity owner signing certificate resolver is unavailable', { stringCode: 'unavailable', retryable: true });
+            signer = await this._entitySignerResolver(signerAid, parsed.signature.cert_fingerprint);
+        }
+        if (signer.aid.toLowerCase() !== signerAid.toLowerCase() || signer.certFingerprint !== parsed.signature.cert_fingerprint)
+            throw new StateError('entity signing certificate changed', { stringCode: 'conflict' });
+        return signer;
+    }
+    async _verifyEntityDocument(target, content) {
+        const primary = await this._entityDocumentSigner(target, content);
+        await verifyAgentMdUpload(content, primary.certPem, target, undefined, async (signer, fingerprint) => {
+            if (!this._entitySignerResolver)
+                throw new StateError('entity additional signing certificate resolver is unavailable', { stringCode: 'unavailable', retryable: true });
+            const material = await this._entitySignerResolver(signer, fingerprint);
+            if (material.aid !== signer || material.certFingerprint !== fingerprint)
+                throw new StateError('entity additional signing certificate changed', { stringCode: 'conflict' });
+            return material;
         });
-        return result;
+    }
+    async _verifyEntityOwnerSigner(owner) {
+        if (!this._entitySignerResolver)
+            throw new StateError('entity owner signing certificate resolver is unavailable', { stringCode: 'unavailable', retryable: true });
+        const fresh = await this._entitySignerResolver(owner.aid, owner.certFingerprint);
+        if (fresh.aid.toLowerCase() !== owner.aid.toLowerCase() || fresh.certFingerprint !== owner.certFingerprint) {
+            throw new StateError('entity owner signing certificate changed', { stringCode: 'conflict' });
+        }
     }
     async download(aid, timeoutMs = DEFAULT_HTTP_TIMEOUT_MS) {
         const target = this._safeAid(String(aid ?? this._ownerAid() ?? '').trim());
         const contentResult = await this._downloadHttp(target, timeoutMs);
-        const parsed = parseAgentMdTailSignature(contentResult.content);
+        const parsed = parseAgentMdTailSignatureForRead(contentResult.content);
+        let entity = false;
+        try {
+            entity = ['group', 'org'].includes(String(parseFileFrontmatter(parsed.payload, false, false).type));
+        }
+        catch { }
+        let frontmatter;
+        try {
+            frontmatter = validateAgentMdDocumentForRead(contentResult.content, { expectedAid: target, validateOwnership: false, ...(entity ? { requireSignature: true } : {}) }).frontmatter;
+        }
+        catch (error) {
+            if (entity)
+                throw new ValidationError(error instanceof Error ? error.message : String(error), { stringCode: 'invalid' });
+            throw error;
+        }
         const expectedFp = parsed.fields?.cert_fingerprint || parsed.fields?.public_key_fingerprint || null;
-        const peer = await this._resolvePeer(target, expectedFp);
-        const verified = await peer.verifyAgentMd(contentResult.content);
+        const signerAid = entity ? (parsed.fields?.signer_aid ?? target) : target;
+        const peer = await this._resolvePeer(signerAid, expectedFp, parsed.fields?.timestamp ? Number(parsed.fields.timestamp) : undefined);
+        const verified = await this._verifyPeerDocument(peer, contentResult.content);
         if (!verified.ok)
             throw new AUNError(verified.error.message);
         const signature = { ...verified.data };
         const statusText = String(signature.status ?? 'invalid');
         const reason = String(signature.reason ?? '').trim();
         if (statusText === 'invalid') {
-            throw new ClientSignatureError(`agent.md verification failed for ${target}${reason ? `: ${reason}` : ''}`);
+            throw new ClientSignatureError(`agent.md verification failed for ${target}${reason ? `: ${reason}` : ''}`, entity ? { stringCode: 'invalid' } : undefined);
+        }
+        let ownershipStatus;
+        if (entity)
+            ownershipStatus = 'not_applicable';
+        else {
+            try {
+                validateOwnershipFrontmatter(frontmatter, target);
+                const rawProof = (frontmatter.ownership_proof ?? {});
+                const subjectSignature = rawProof.subject_signature;
+                const ownerSignature = rawProof.owner_signature;
+                const release = frontmatter.ownership_release;
+                const subjectCertPem = subjectSignature ? (await this._resolvePeer(target, String(subjectSignature.cert_fingerprint), isJsonObject(subjectSignature.statement) ? Number(subjectSignature.statement.signed_at) : undefined)).certPem : undefined;
+                const ownerAid = String(ownerSignature ? frontmatter.owner : release?.statement && typeof release.statement === 'object' ? release.statement.owner_aid : '');
+                const ownerFingerprint = String(ownerSignature?.cert_fingerprint ?? release?.cert_fingerprint ?? '');
+                const ownerStatement = (ownerSignature ?? release)?.statement;
+                const ownerCertPem = ownerFingerprint ? (await this._resolvePeer(ownerAid, ownerFingerprint, isJsonObject(ownerStatement) ? Number(ownerStatement.signed_at) : undefined)).certPem : undefined;
+                ownershipStatus = await verifyOwnershipFrontmatterStatus(frontmatter, subjectCertPem, ownerCertPem);
+            }
+            catch {
+                ownershipStatus = 'invalid';
+            }
         }
-        const verification = { status: statusText };
+        const verification = { status: statusText, ownership_status: ownershipStatus };
         if (reason)
             verification.reason = reason;
         const localEtag = await AgentMdManager.contentEtag(contentResult.content);
@@ -557,7 +1131,7 @@ export class AgentMdManager {
         const root = this.root;
         await this._writeStorage(this._contentKey(aid), String(content ?? ''), root);
     }
-    async loadRecord(aid) {
+    async loadRecord(aid, strict = false) {
         const target = String(aid ?? '').trim();
         if (!target)
             return null;
@@ -565,7 +1139,7 @@ export class AgentMdManager {
         const generation = this._storageGeneration;
         try {
             const loaded = await this._withLock(async () => {
-                const record = await this._readRecordUnlocked(target, root);
+                const record = await this._readRecordUnlocked(target, root, strict);
                 const next = Object.keys(record).length > 0 ? { ...record, aid: target } : { aid: target };
                 try {
                     const content = await this._readStorage(this._contentKey(target), root);
@@ -591,6 +1165,8 @@ export class AgentMdManager {
             return { ...loaded };
         }
         catch (err) {
+            if (strict)
+                throw err;
             this._log.debug(`agent.md cache load skipped: aid=${target} err=${err instanceof Error ? err.message : String(err)}`);
             return null;
         }
@@ -601,10 +1177,12 @@ export class AgentMdManager {
             return {};
         const root = this.root;
         const generation = this._storageGeneration;
+        let strictDraft = false;
         try {
             const inputFields = { ...fields };
+            strictDraft = typeof inputFields.local_draft_content === 'string';
             const hasContent = Object.prototype.hasOwnProperty.call(inputFields, 'content') && inputFields.content !== undefined && inputFields.content !== null;
-            if (hasContent) {
+            if (hasContent && !strictDraft) {
                 const text = String(inputFields.content ?? '');
                 await this._writeStorage(this._contentKey(target), text, root);
                 if (!inputFields.local_etag)
@@ -614,8 +1192,18 @@ export class AgentMdManager {
             }
             delete inputFields.content;
             const record = await this._withLock(async () => {
-                const next = { ...(await this._readRecordUnlocked(target, root)), aid: target };
+                const next = { ...(await this._readRecordUnlocked(target, root, strictDraft)), aid: target };
+                if (hasContent && strictDraft) {
+                    const text = String(fields.content ?? '');
+                    await this._writeStorage(this._contentKey(target), text, root);
+                    if (!inputFields.local_etag)
+                        inputFields.local_etag = await AgentMdManager.contentEtag(text);
+                    if (!inputFields.fetched_at)
+                        inputFields.fetched_at = Date.now();
+                }
                 for (const [key, value] of Object.entries(inputFields)) {
+                    if (key === 'local_draft_content' && value === '' && hasContent && next.local_draft_content !== fields.content)
+                        continue;
                     if (value !== undefined && value !== null)
                         next[key] = value;
                 }
@@ -631,6 +1219,8 @@ export class AgentMdManager {
             return { ...loaded };
         }
         catch (err) {
+            if (strictDraft)
+                throw err;
             this._log.debug(`agent.md cache save skipped: aid=${target} err=${err instanceof Error ? err.message : String(err)}`);
             return {};
         }
@@ -690,17 +1280,20 @@ export class AgentMdManager {
     async _resolveGateway(aid) {
         return String(await this._gatewayResolver?.(aid) ?? '');
     }
-    async _resolvePeer(aid, certFingerprint) {
-        const expectedFp = String(certFingerprint ?? '').trim().toLowerCase();
+    async _resolvePeer(aid, certFingerprint, signedAt) {
+        const normalizedFp = normalizeFingerprintHex(certFingerprint);
+        const expectedFp = normalizedFp ? `sha256:${normalizedFp}` : String(certFingerprint ?? '').trim().toLowerCase();
         const current = this._currentAid();
         if (current && current.aid.toLowerCase() === aid.toLowerCase()) {
             if (!expectedFp || await certMatchesFingerprint(current.certPem, expectedFp))
                 return current;
         }
-        const peer = await this._peerResolver?.(aid, expectedFp || null);
+        const peer = await this._peerResolver?.(aid, expectedFp || null, signedAt);
         if (!(peer instanceof AID)) {
             throw new StateError(`agent.md peer resolver did not return AID for ${aid}`);
         }
+        if (peer.aid.toLowerCase() !== aid.toLowerCase())
+            throw new ClientSignatureError(`agent.md signer does not match requested AID: ${aid}`, { stringCode: 'invalid' });
         return peer;
     }
     async _accessToken(aid, gatewayUrl) {
@@ -709,22 +1302,57 @@ export class AgentMdManager {
             throw new StateError('authenticate did not return access_token');
         return token;
     }
+    async _uploadAccessToken(aid, gatewayUrl) {
+        const resolver = this._uploadAccessTokenResolver ?? this._accessTokenResolver;
+        const token = String(await resolver?.(aid, gatewayUrl) ?? '').trim();
+        if (!token)
+            throw new StateError('authenticate did not return access_token');
+        return token;
+    }
+    async _ownerUploadAuthorization(target, content, owner) {
+        const bodySha256 = await sha256Hex(content);
+        const timestamp = Math.floor(Date.now() / 1000);
+        const nonce = randomOwnerAuthorizationNonce();
+        const canonical = `AUN-AGENT-MD-UPLOAD-V1;${owner.aid.toLowerCase()};${target.toLowerCase()};${bodySha256};${timestamp};${nonce}`;
+        const signed = await owner.sign(canonical);
+        if (!signed.ok || !signed.data) {
+            const message = signed.error?.message || 'owner authorization signing failed';
+            throw new ClientSignatureError(message);
+        }
+        return base64UrlEncode(JSON.stringify({
+            version: 1,
+            target_aid: target.toLowerCase(),
+            uploader_aid: owner.aid.toLowerCase(),
+            body_sha256: bodySha256,
+            timestamp,
+            nonce,
+            cert_fingerprint: owner.certFingerprint,
+            signature: signed.data.signature,
+        }));
+    }
     _url(aid, gatewayUrl) {
         return `${agentMdHttpScheme(gatewayUrl)}://${this._safeAid(aid)}/agent.md`;
     }
-    async _uploadHttp(aid, content, ownerOperationId) {
+    async _uploadHttp(aid, content, ownerAuthorization = '', condition, legacyBodyUpdate = false) {
+        if (!condition || Object.keys(condition).length !== 1 || !(typeof condition.if_match === 'string' && condition.if_match || condition.if_none_match === '*'))
+            throw new StateError('agent.md upload requires its original document condition', { stringCode: 'persistence_unavailable' });
         const gatewayUrl = await this._resolveGateway(aid);
-        const token = await this._accessToken(aid, gatewayUrl);
+        const authorization = String(ownerAuthorization ?? '').trim();
+        const meta = validateAgentMdDocument(content, { expectedAid: aid, validateOwnership: false }).frontmatter;
+        const entity = ['group', 'org'].includes(String(meta.type));
         // 浏览器禁止覆盖 Host；动态 AID URL 由浏览器/Docker 的通配解析路由。
         const viaGatewayHost = this._uploadViaGatewayHost && nodeBuiltin('node:http') !== null;
-        const headers = {
-            Authorization: `Bearer ${token}`,
+        const headers = { 'X-AUN-Signature-Format': 'multi-v1',
             'Content-Type': 'text/markdown; charset=utf-8',
+            ...(!entity && !(legacyBodyUpdate && this._isLegacyBodyRelation(meta)) ? { 'X-AUN-Ownership-Check': '1' } : {}),
+            ...(condition.if_match ? { 'If-Match': condition.if_match } : { 'If-None-Match': '*' }),
             ...(viaGatewayHost ? { Host: this._safeAid(aid) } : {}),
+            ...(!entity && authorization ? { 'X-AUN-AgentMD-Owner-Authorization': authorization } : {}),
         };
-        const operationId = String(ownerOperationId ?? '').trim();
-        if (operationId)
-            headers['X-AUN-Owner-Operation-ID'] = operationId;
+        if (!authorization || entity) {
+            const token = await this._uploadAccessToken(aid, gatewayUrl);
+            headers.Authorization = `Bearer ${token}`;
+        }
         let url = this._url(aid, gatewayUrl);
         if (viaGatewayHost) {
             try {
@@ -744,7 +1372,7 @@ export class AgentMdManager {
         }
         let response;
         try {
-            response = await fetchWithTimeout(url, { method: 'PUT', headers, body: content });
+            response = await fetchWithTimeout(url, { method: 'PUT', headers, body: content, redirect: 'error' });
         }
         catch (error) {
             if (!viaGatewayHost)
@@ -752,12 +1380,12 @@ export class AgentMdManager {
             const fallbackUrl = nameServiceAgentMdUrl(aid, gatewayUrl);
             if (!fallbackUrl || fallbackUrl === url)
                 throw error;
-            response = await fetchWithTimeout(fallbackUrl, { method: 'PUT', headers, body: content });
+            response = await fetchWithTimeout(fallbackUrl, { method: 'PUT', headers, body: content, redirect: 'error' });
         }
         if (response.status === 404 && viaGatewayHost) {
             const fallbackUrl = nameServiceAgentMdUrl(aid, gatewayUrl);
             if (fallbackUrl && fallbackUrl !== url) {
-                response = await fetchWithTimeout(fallbackUrl, { method: 'PUT', headers, body: content });
+                response = await fetchWithTimeout(fallbackUrl, { method: 'PUT', headers, body: content, redirect: 'error' });
             }
         }
         if (response.status === 404) {
@@ -765,6 +1393,10 @@ export class AgentMdManager {
         }
         if (!response.ok) {
             const message = (await response.text()).trim();
+            if (entity) {
+                const code = response.status === 409 || response.status === 412 ? 'conflict' : response.status === 401 || response.status === 403 ? 'forbidden' : response.status === 428 ? 'unsupported_protocol' : response.status >= 500 ? 'unavailable' : 'invalid';
+                throw new StateError(`upload agent.md failed: HTTP ${response.status}${message ? ` - ${message}` : ''}`, { stringCode: code, retryable: code === 'unavailable' });
+            }
             throw new AUNError(`upload agent.md failed: HTTP ${response.status}${message ? ` - ${message}` : ''}`);
         }
         const payload = await response.json();
@@ -777,13 +1409,13 @@ export class AgentMdManager {
         const cached = await this.loadRecord(target) ?? {};
         const gatewayUrl = await this._resolveGateway(target);
         const url = this._url(target, gatewayUrl);
-        const headers = { Accept: 'text/markdown' };
+        const headers = { 'X-AUN-Signature-Format': 'multi-v1', Accept: 'text/markdown' };
         const cachedEtag = String(cached.remote_etag ?? cached.etag ?? cached.local_etag ?? '').trim();
         const cachedLastModified = String(cached.last_modified ?? '').trim();
         let response = await fetchWithTimeout(url, {
             method: 'GET',
             headers,
-            redirect: 'follow',
+            redirect: 'error',
         }, timeoutMs);
         if (response.status === 304 && cached.content !== undefined && cached.content !== null) {
             return {
@@ -796,8 +1428,8 @@ export class AgentMdManager {
         if (response.status === 304) {
             response = await fetchWithTimeout(url, {
                 method: 'GET',
-                headers: { Accept: 'text/markdown' },
-                redirect: 'follow',
+                headers: { 'X-AUN-Signature-Format': 'multi-v1', Accept: 'text/markdown' },
+                redirect: 'error',
             }, timeoutMs);
         }
         if (response.status === 404) {
@@ -806,9 +1438,15 @@ export class AgentMdManager {
         }
         if (!response.ok) {
             const message = (await response.text()).trim();
-            throw new AUNError(`download agent.md failed: HTTP ${response.status}${message ? ` - ${message}` : ''}`);
+            throw new AUNError(`download agent.md failed: HTTP ${response.status}${message ? ` - ${message}` : ''}`, response.status >= 500 ? { stringCode: 'unavailable', retryable: true } : undefined);
+        }
+        let content;
+        try {
+            content = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(await response.arrayBuffer());
+        }
+        catch {
+            throw new ValidationError('agent.md must be valid UTF-8', { stringCode: 'invalid' });
         }
-        const content = await response.text();
         return {
             content,
             etag: headerValue(response.headers, 'ETag') || cachedEtag,
@@ -821,7 +1459,7 @@ export class AgentMdManager {
         const gatewayUrl = await this._resolveGateway(target);
         const response = await fetchWithTimeout(this._url(target, gatewayUrl), {
             method: 'HEAD',
-            headers: { Accept: 'text/markdown' },
+            headers: { 'X-AUN-Signature-Format': 'multi-v1', Accept: 'text/markdown' },
         }, HEAD_HTTP_TIMEOUT_MS);
         const etag = headerValue(response.headers, 'ETag');
         const lastModified = headerValue(response.headers, 'Last-Modified');
@@ -916,14 +1554,22 @@ export class AgentMdManager {
         payload.aid = this._safeAid(aid);
         await this._writeStorage(this._metaKey(aid), `${JSON.stringify(payload, null, 2)}\n`, root);
     }
-    async _readRecordUnlocked(aid, root = this.root) {
-        const raw = await this._readStorage(this._metaKey(aid), root);
-        if (raw === null)
-            return {};
+    async _readRecordUnlocked(aid, root = this.root, strict = false) {
         try {
-            return this._normalizeRecord(aid, JSON.parse(raw));
+            const raw = await this._readStorage(this._metaKey(aid), root);
+            if (raw === null)
+                return {};
+            const parsed = JSON.parse(raw);
+            if (strict && !isRecord(parsed))
+                throw new StateError('agent.md metadata is damaged', { stringCode: 'persistence_unavailable' });
+            return this._normalizeRecord(aid, parsed);
         }
         catch (err) {
+            if (strict) {
+                if (err instanceof StateError)
+                    throw err;
+                throw new StateError('agent.md metadata is damaged', { stringCode: 'persistence_unavailable' });
+            }
             this._log.warn(`agent.md metadata damaged, ignoring: aid=${aid} err=${err instanceof Error ? err.message : String(err)}`);
             return {};
         }