@agentunion/fastaun-browser 0.5.20 → 0.5.21

package/dist/agent-md.js

@@ -18,7 +18,7 @@ export function buildOwnershipAgentMdV21(content, 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);
+    const match = /^\ufeff?---(?:\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 });
@@ -34,7 +34,7 @@ function updateOwnershipAgentMd(content, fields) {
     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]}`;
+    const updated = `${payload.startsWith('\ufeff') ? '\ufeff' : ''}---\n${yamlText.endsWith('\n') ? yamlText : `${yamlText}\n`}---${match[2]}`;
     validateAgentMdDocument(updated, { expectedAid: String(frontmatter.aid ?? '') });
     return updated;
 }
@@ -206,6 +206,10 @@ function requestWithNodeHost(input, init, timeoutMs) {
         }
     });
 }
+export function readAgentMdFrontmatter(content) {
+    const payload = parseAgentMdTailSignatureForRead(content).payload;
+    return payload.replace(/^\ufeff/, '').split(/\r\n|\n|\r/, 1)[0]?.trim() === '---' ? parseFileFrontmatter(payload, true, false) : {};
+}
 async function fetchWithTimeout(input, init, timeoutMs = DEFAULT_HTTP_TIMEOUT_MS) {
     if (new Headers(init.headers).has('host')) {
         return await requestWithNodeHost(input, init, timeoutMs);
@@ -344,10 +348,19 @@ export class AgentMdManager {
             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' });
+        if (response.status === 400) {
+            let failure;
+            try {
+                failure = await response.json();
+            }
+            catch { }
+            if (isJsonObject(failure) && failure.error === 'invalid')
+                throw new ValidationError('NS ownership material is invalid', { stringCode: 'invalid' });
+        }
+        if (!response.ok && response.status !== 404)
+            throw new StateError(`NS ownership check unavailable: HTTP ${response.status}`, { stringCode: 'unavailable', retryable: true });
         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');
@@ -369,7 +382,7 @@ export class AgentMdManager {
         }
         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) {
+    async submitOwnershipRaw(aid, content, condition, guard) {
         const target = this._safeAid(aid);
         if (this._currentAid()?.aid !== target)
             throw new ValidationError('ownership upload requires its own identity', { stringCode: 'forbidden' });
@@ -378,15 +391,44 @@ export class AgentMdManager {
             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': '*' }) },
-        });
+        const viaGatewayHost = this._uploadViaGatewayHost && nodeBuiltin('node:http') !== null;
+        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 submit = async (targetUrl) => {
+            await guard?.();
+            return fetchWithTimeout(targetUrl, {
+                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}`,
+                    ...(viaGatewayHost ? { Host: target } : {}),
+                    ...(condition.if_match ? { 'If-Match': condition.if_match } : { 'If-None-Match': '*' }) },
+            });
+        };
+        let response;
+        try {
+            response = await submit(url);
+        }
+        catch (error) {
+            if (!viaGatewayHost)
+                throw error;
+            const fallback = nameServiceAgentMdUrl(target, gatewayUrl);
+            if (!fallback || fallback === url)
+                throw error;
+            url = fallback;
+            response = await submit(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 submit(fallback);
+        }
         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' });
+            throw new StateError(`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);
     }
@@ -476,9 +518,30 @@ export class AgentMdManager {
             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')
+        const priorRelation = this._isLegacyBodyRelation(meta) && pending.relation && Object.keys(pending.relation).length === 4 && ['relation_version', 'lock', 'owner_aid', 'statement'].every((field) => Object.hasOwn(pending.relation, field));
+        if (this._isLegacyBodyRelation(meta) && pending.relation?.protocol !== 'legacy' && !priorRelation)
             throw new StateError('legacy ownership pending agent.md requires its original relationship snapshot', { stringCode: 'unsupported_protocol' });
         try {
+            if (priorRelation) {
+                const relation = pending.relation, statement = parseOwnershipFile(pending.content, 'agent', { expectedSubAid: aid }).statement;
+                if (!statement || !this._sameBodyRelation(statement, relation.statement) || statement.relation_version !== relation.relation_version || statement.owner_aid !== relation.owner_aid || !['locked', 'unlocked'].includes(String(relation.lock)) || pending.content_etag !== await AgentMdManager.contentEtag(pending.content))
+                    throw new StateError('pending original relationship context is corrupt', { stringCode: 'persistence_unavailable' });
+                const identity = signer ?? this._currentAid();
+                if (!identity || identity.aid !== aid || this._currentAid()?.aid !== aid || this._ownerAid() !== aid)
+                    throw new StateError('body recovery requires its current subject identity', { stringCode: 'forbidden' });
+                await this._verifyBodyUpload(aid, pending.content, identity);
+                const remote = await this.readAgentMdFresh(aid);
+                if (!remote.exists || !this._sameBodyRelation(this._bodyRelationFields(meta), this._bodyRelationFields(validateAgentMdDocumentForRead(remote.content, { expectedAid: aid, validateOwnership: false }).frontmatter)))
+                    throw new StateError('pending agent.md relationship material changed', { stringCode: 'conflict' });
+                if (remote.etag === pending.content_etag && remote.content === pending.content) {
+                    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.etag !== condition.if_match)
+                    throw new StateError('pending agent.md original document condition changed', { stringCode: 'conflict' });
+                await this._uploadPrepared(aid, pending.content, identity, condition);
+                return true;
+            }
             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))
@@ -487,7 +550,7 @@ export class AgentMdManager {
                 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' });
+                    throw new StateError('legacy relationship material changed', { stringCode: 'conflict' });
                 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' });
@@ -533,26 +596,11 @@ export class AgentMdManager {
                     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 (pending.content_etag !== await AgentMdManager.contentEtag(pending.content))
+                throw new StateError('pending agent.md original bytes are corrupt', { stringCode: 'persistence_unavailable' });
+            const remote = await this.readAgentMdFresh(aid);
+            if (remote.exists && this._isLegacyBodyRelation(validateAgentMdDocumentForRead(remote.content, { expectedAid: aid, validateOwnership: false }).frontmatter))
+                throw new StateError('legacy relationship material cannot be removed or replaced', { stringCode: 'conflict' });
             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)
@@ -580,12 +628,7 @@ export class AgentMdManager {
     _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));
+        return ['owner', 'ownership', '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]]));
@@ -594,14 +637,32 @@ export class AgentMdManager {
         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) {
+    async readAgentMdFresh(aid) {
+        const target = this._safeAid(aid);
         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' });
+        const viaGatewayHost = this._uploadViaGatewayHost && nodeBuiltin('node:http') !== null;
+        const headers = { 'X-AUN-Signature-Format': 'multi-v1', Accept: 'text/markdown', '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', headers, cache: 'no-store', redirect: 'error' });
+        }
+        catch (error) {
+            const fallback = viaGatewayHost ? nameServiceAgentMdUrl(target, gateway) : '';
+            if (!fallback || fallback === url)
+                throw error;
+            response = await fetchWithTimeout(fallback, { method: 'GET', headers, 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' });
+            return { exists: false, content: '', etag: '', last_modified: '', status: 404 };
         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 });
+            throw new StateError('agent.md 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());
@@ -609,7 +670,13 @@ export class AgentMdManager {
         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 };
+        return { exists: true, content, etag, last_modified: headerValue(response.headers, 'Last-Modified'), status: 200 };
+    }
+    async _readLegacyBodyFresh(target) {
+        const fresh = await this.readAgentMdFresh(target);
+        if (!fresh.exists)
+            throw new StateError('legacy relationship cannot be created by an ordinary body update', { stringCode: 'unsupported_protocol' });
+        return fresh;
     }
     async _verifyLegacyBodyOriginal(target, content) {
         const parsed = validateAgentMdDocumentForRead(content, { expectedAid: target, validateOwnership: false, requireSignature: true });
@@ -658,30 +725,21 @@ export class AgentMdManager {
         if (entity)
             await this._verifyEntityDocument(target, signed);
         let condition = originalCondition;
-        let relation = entityContext ?? (await this.pendingUpload(target))?.relation;
+        const pendingRelation = originalCondition ? (await this.pendingUpload(target))?.relation : undefined;
+        let relation = entityContext ?? (pendingRelation?.protocol === 'legacy' ? pendingRelation : {});
         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;
-                }
-            }
+            else
+                fresh = entity ? await this._readEntityFresh(target) : await this.readAgentMdFresh(target);
             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)))
+                if (!freshMeta || !this._isLegacyBodyRelation(freshMeta))
                     throw new StateError('legacy relationship changes require their original protocol', { stringCode: 'unsupported_protocol' });
+                if (!this._sameBodyRelation(this._bodyRelationFields(meta), this._bodyRelationFields(freshMeta)))
+                    throw new StateError('legacy relationship material changed', { stringCode: 'conflict' });
                 if (!fresh.etag)
                     throw new StateError('legacy original document ETag is unavailable', { stringCode: 'unavailable', retryable: true });
                 await this._verifyLegacyBodyOriginal(target, fresh.content);
@@ -689,20 +747,14 @@ export class AgentMdManager {
                 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 };
-                }
+                condition = 'exists' in fresh && fresh.exists ? { if_match: fresh.etag } : { if_none_match: '*' };
             }
         }
         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' });
+                throw new StateError('legacy relationship material changed', { stringCode: 'conflict' });
             await this._verifyBodyUpload(target, signed, signer);
         }
         const entityAuthorization = '';
@@ -718,7 +770,7 @@ export class AgentMdManager {
             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 result = await this._uploadHttp(target, signed, authorization, condition);
             const remoteEtag = String(result.etag ?? '').trim();
             const contentEtag = await AgentMdManager.contentEtag(signed);
             const saved = await this.saveRecord(target, {
@@ -927,6 +979,7 @@ export class AgentMdManager {
         return {
             aid: target,
             content: contentResult.content,
+            frontmatter: readAgentMdFrontmatter(contentResult.content),
             verification,
             signature,
             cert_pem: peer.certPem,
@@ -1127,6 +1180,31 @@ export class AgentMdManager {
         const root = this.root;
         return await this._readStorage(this._contentKey(aid), root);
     }
+    async ownType() {
+        try {
+            const target = this._ownerAid();
+            const current = this._currentAid();
+            if (!target || !current?.isCertValid() || current.aid.toLowerCase() !== target.toLowerCase())
+                return '';
+            const record = await this.loadRecord(target);
+            const content = String(record?.local_draft_content ?? '') || String(record?.content ?? '') || await this.readContent(target) || '';
+            if (!content)
+                return '';
+            const parsed = validateAgentMdDocumentForRead(content, { expectedAid: target, validateOwnership: false, requireSignature: true });
+            const type = parseFileFrontmatter(parsed.payload, false, false).type;
+            if (typeof type !== 'string' || !type.trim())
+                return '';
+            const verified = await current.verifyAgentMd(content, async (signer, fingerprint) => {
+                if (signer.toLowerCase() === current.aid.toLowerCase() && await certMatchesFingerprint(current.certPem, fingerprint))
+                    return current;
+                throw new StateError('自身 agent.md 签名证书不在本地可信身份中');
+            });
+            return verified.ok && verified.data.status === 'verified' ? type.trim() : '';
+        }
+        catch {
+            return '';
+        }
+    }
     async writeContent(aid, content) {
         const root = this.root;
         await this._writeStorage(this._contentKey(aid), String(content ?? ''), root);
@@ -1333,7 +1411,7 @@ export class AgentMdManager {
     _url(aid, gatewayUrl) {
         return `${agentMdHttpScheme(gatewayUrl)}://${this._safeAid(aid)}/agent.md`;
     }
-    async _uploadHttp(aid, content, ownerAuthorization = '', condition, legacyBodyUpdate = false) {
+    async _uploadHttp(aid, content, ownerAuthorization = '', condition) {
         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);
@@ -1344,7 +1422,6 @@ export class AgentMdManager {
         const viaGatewayHost = this._uploadViaGatewayHost && nodeBuiltin('node:http') !== null;
         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 } : {}),