@agentunion/fastaun 0.5.17 → 0.5.19

package/dist/agent-md.js

@@ -3,13 +3,44 @@ import * as fs from 'node:fs';
 import * as http from 'node:http';
 import * as https from 'node:https';
 import * as path from 'node:path';
+import { parseDocument } from 'yaml';
 import { AID } from './aid.js';
 import { certMatchesFingerprint, parseAgentMdTailSignature } from './cert-utils.js';
-import { validateAgentMdDocument, verifyAgentMdUpload } from './agent-md-schema.js';
+import { parseFileFrontmatter, validateAgentMdDocument, verifyAgentMdUpload } 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 { ownershipFailure, parseOwnershipFile } from './ownership-v21.js';
 const DEFAULT_HTTP_TIMEOUT_MS = 30_000;
 const AGENT_MD_NEGATIVE_CACHE_TTL_MS = 60_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 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');
+    document.delete('ownership_proof');
+    document.delete('ownership_release');
+    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';
@@ -22,6 +53,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)}`] : []),
@@ -122,11 +157,13 @@ function requestText(url, opts) {
             const chunks = [];
             res.on('data', (chunk) => chunks.push(chunk));
             res.on('end', () => {
-                resolve({
-                    status,
-                    headers: toHeaders(res.headers),
-                    text: Buffer.concat(chunks).toString('utf-8'),
-                });
+                try {
+                    const bytes = Buffer.concat(chunks);
+                    resolve({ status, headers: toHeaders(res.headers), text: opts.strictUtf8 ? new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes) : bytes.toString('utf-8') });
+                }
+                catch {
+                    reject(ownershipFailure(status >= 200 && status < 300 ? 'invalid' : 'unavailable', 'agent.md response is not valid UTF-8', status < 200 || status >= 300));
+                }
             });
             res.on('error', reject);
         });
@@ -148,10 +185,14 @@ export class AgentMdManager {
     _discoveryPort;
     _uploadViaGatewayHost;
     _ownerAidGetter;
+    _entityIdentityGetter;
+    _entityOwnerResolver;
+    _entitySignerResolver;
     _currentAidGetter;
     _gatewayResolver;
     _peerResolver;
     _accessTokenResolver;
+    _uploadAccessTokenResolver;
     _aidValidator;
     _cache = new Map();
     _downloadInflight = new Map();
@@ -165,10 +206,14 @@ export class AgentMdManager {
         this._discoveryPort = opts.discoveryPort ?? null;
         this._uploadViaGatewayHost = opts.uploadViaGatewayHost ?? false;
         this._ownerAidGetter = opts.ownerAidGetter;
+        this._entityIdentityGetter = opts.entityIdentityGetter;
+        this._entityOwnerResolver = opts.entityOwnerResolver;
+        this._entitySignerResolver = opts.entitySignerResolver;
         this._currentAidGetter = opts.currentAidGetter;
         this._gatewayResolver = opts.gatewayResolver;
         this._peerResolver = opts.peerResolver;
         this._accessTokenResolver = opts.accessTokenResolver;
+        this._uploadAccessTokenResolver = opts.uploadAccessTokenResolver;
         this._aidValidator = opts.aidValidator;
     }
     static contentEtag(content) {
@@ -297,7 +342,9 @@ export class AgentMdManager {
         const rawContent = content === undefined || content === null ? this.readContent(target) : String(content);
         if (!rawContent.trim())
             throw new ValidationError('uploadAgentMd requires non-empty content');
-        validateAgentMdDocument(rawContent, { expectedAid: target });
+        const parsed = validateAgentMdDocument(rawContent, { expectedAid: target });
+        if (['group', 'org'].includes(String(parsed.frontmatter.type)))
+            return await this.uploadAs(target, rawContent, current);
         const signed = current.signAgentMd(rawContent);
         if (!signed.ok || !signed.data) {
             const message = signed.error?.message ?? 'agent.md signing failed';
@@ -305,13 +352,387 @@ export class AgentMdManager {
         }
         const signedContent = signed.data.signed;
         verifyAgentMdUpload(signedContent, current.certPem, target);
+        return await this._uploadPrepared(target, signedContent, current);
+    }
+    async readOwnershipFresh(aid) {
+        const target = this.safeAid(aid);
+        const response = await this._ownershipRequest(target, 'GET');
+        if (response.status !== 200 && response.status !== 404)
+            throw ownershipFailure('unavailable', `NS fresh read failed: HTTP ${response.status}`, true);
+        if (headerValue(response.headers, 'X-AUN-Ownership-Status') === 'not_applicable')
+            throw ownershipFailure('not_applicable', 'group/org uses its lifecycle owner relationship');
+        let type;
+        if (response.status === 200) {
+            try {
+                type = parseFileFrontmatter(parseAgentMdTailSignature(response.text).payload).type;
+            }
+            catch { }
+        }
+        if (['group', 'org'].includes(String(type)))
+            throw ownershipFailure('not_applicable', 'group/org uses its lifecycle owner relationship');
+        const protocol = headerValue(response.headers, 'X-AUN-Ownership-Protocol');
+        if (protocol !== '2.1')
+            throw ownershipFailure('unsupported_protocol', 'NS does not provide Ownership 2.1 metadata');
+        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 (!/^(?:0|[1-9][0-9]*)$/.test(version) || !Number.isSafeInteger(Number(version)) || !['locked', 'unlocked'].includes(lock) || response.status === 200 && !etag || response.status === 404 && (version !== '0' || lock !== 'unlocked'))
+            throw ownershipFailure('unavailable', 'NS fresh metadata is incomplete', true);
+        return { sub_aid: target, exists: response.status === 200, content: response.status === 200 ? response.text : '', etag, protocol, relation_version: Number(version), lock: lock, observed_at: Math.floor(Date.now() / 1000) };
+    }
+    async submitOwnershipRaw(aid, raw, condition) {
+        const target = this.safeAid(aid), current = this._currentAid();
+        if (!current?.isPrivateKeyValid() || current.aid !== target || this._ownerAid() !== target)
+            throw ownershipFailure('forbidden', 'raw agent.md submission requires its own authenticated identity');
+        if (!condition || !condition.if_match && condition.if_none_match !== '*' || condition.if_match && condition.if_none_match)
+            throw new ValidationError('raw agent.md requires one original condition');
+        parseOwnershipFile(raw, 'agent', { expectedSubAid: target });
+        verifyAgentMdUpload(raw, current.certPem, target);
+        const response = await this._ownershipRequest(target, 'PUT', raw, condition);
+        if (response.status === 409 || response.status === 412)
+            throw ownershipFailure('conflict', `NS original condition failed: HTTP ${response.status}`);
+        if (response.status === 428)
+            throw ownershipFailure('unsupported_protocol', 'NS does not support the required original document condition');
+        if (response.status === 401 || response.status === 403)
+            throw ownershipFailure('forbidden', `NS self submission denied: HTTP ${response.status}`);
+        if (response.status < 200 || response.status >= 300)
+            throw ownershipFailure('unavailable', `NS raw submission failed: HTTP ${response.status}`, true);
+        const fresh = await this.readOwnershipFresh(target);
+        if (fresh.content !== raw)
+            throw ownershipFailure('unavailable', 'NS raw submission cannot be confirmed from the current document', true);
+        this.saveRecord(target, { content: raw, local_etag: AgentMdManager.contentEtag(raw), remote_etag: fresh.etag, fetched_at: Date.now(), checked_at: Date.now(), remote_status: 'found' });
+        return fresh;
+    }
+    async _ownershipRequest(target, method, raw, condition) {
         const gatewayUrl = await this._resolveGateway(target);
-        const token = await this._accessToken(target, gatewayUrl);
+        const headers = { Accept: 'text/markdown', 'Cache-Control': 'no-cache', 'X-AUN-Ownership-Check': '1' };
+        if (method === 'PUT') {
+            headers['Content-Type'] = 'text/markdown; charset=utf-8';
+            headers.Authorization = `Bearer ${await this._uploadAccessToken(target, gatewayUrl)}`;
+            if (condition?.if_match)
+                headers['If-Match'] = condition.if_match;
+            else if (condition?.if_none_match)
+                headers['If-None-Match'] = condition.if_none_match;
+        }
+        const viaGateway = this._uploadViaGatewayHost;
+        if (viaGateway)
+            headers.Host = target;
+        const request = (url) => requestText(url, { method, verifySsl: this._verifySsl, headers, body: raw, timeoutMs: DEFAULT_HTTP_TIMEOUT_MS, redirectsLeft: 0, strictUtf8: true });
+        let response = await request(this._url(target, gatewayUrl, viaGateway));
+        if (response.status === 404 && !headerValue(response.headers, 'X-AUN-Ownership-Protocol') && headerValue(response.headers, 'X-AUN-Ownership-Status') !== 'not_applicable') {
+            const fallback = nameServiceAgentMdUrl(target, gatewayUrl);
+            if (fallback && fallback !== this._url(target, gatewayUrl, viaGateway)) {
+                headers.Host = target;
+                response = await request(fallback);
+            }
+        }
+        return response;
+    }
+    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 = validateAgentMdDocument(rawContent, { expectedAid: target });
+        if (['group', 'org'].includes(String(parsed.frontmatter.type)) && parsed.signature) {
+            const identity = await this._entitySigningIdentity(target, parsed.frontmatter, parsed.signature, signer);
+            verifyAgentMdUpload(rawContent, identity.certPem, target);
+            return await this._uploadPrepared(target, rawContent, identity);
+        }
+        if (!signer?.isPrivateKeyValid())
+            throw new StateError('uploadAgentMd requires a valid signer identity');
+        if (['group', 'org'].includes(String(parsed.frontmatter.type)))
+            await this._entityContext(target, parsed.frontmatter, signer);
+        const signed = signer.signAgentMd(rawContent);
+        if (!signed.ok || !signed.data) {
+            const message = signed.error?.message ?? 'agent.md signing failed';
+            throw new ClientSignatureError(message);
+        }
+        const signedContent = signed.data.signed;
+        verifyAgentMdUpload(signedContent, signer.certPem, target);
+        return await this._uploadPrepared(target, signedContent, signer);
+    }
+    pendingUpload(aid) {
+        const record = 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 = 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 ownershipFailure('persistence_unavailable', 'pending agent.md requires its original document condition');
+        const parsed = validateAgentMdDocument(pending.content, { expectedAid: aid, validateOwnership: false });
+        const meta = parsed.frontmatter;
+        if ('ownership_proof' in meta || 'ownership_release' in meta)
+            throw ownershipFailure('unsupported_protocol', 'legacy ownership pending agent.md cannot be recovered through ordinary upload');
+        try {
+            if (['group', 'org'].includes(String(meta.type))) {
+                if (!parsed.signature)
+                    throw ownershipFailure('invalid', 'pending entity agent.md requires a signature');
+                const identity = await this._entitySigningIdentity(aid, meta, parsed.signature, signer ?? this._currentAid() ?? undefined);
+                const context = await this._entityContext(aid, meta, identity);
+                if (!pending.relation?.entity_cert_fingerprint)
+                    throw ownershipFailure('persistence_unavailable', 'pending entity upload requires original owner and certificate context');
+                if (pending.relation.owner_aid !== context.owner_aid)
+                    throw ownershipFailure('forbidden', 'pending entity upload belongs to a different owner');
+                if (pending.relation.entity_cert_fingerprint !== context.entity_cert_fingerprint)
+                    throw ownershipFailure('conflict', 'pending entity upload belongs to an old rekey generation');
+                if (pending.content_etag !== AgentMdManager.contentEtag(pending.content))
+                    throw ownershipFailure('persistence_unavailable', 'pending entity original bytes are corrupt');
+                verifyAgentMdUpload(pending.content, identity.certPem, aid);
+                const uploader = this._currentAid();
+                if (uploader.aid.toLowerCase() !== aid.toLowerCase())
+                    this._validateEntityUploadAuthorization(pending.authorization, aid, pending.content, uploader, String(context.entity_cert_fingerprint));
+                const remote = await this._readEntityFresh(aid);
+                if (remote.exists && remote.content === pending.content && remote.etag === pending.content_etag) {
+                    this.saveRecord(aid, { content: pending.content, remote_etag: remote.etag, 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 ownershipFailure('conflict', 'pending agent.md original document condition changed');
+                await this._uploadPrepared(aid, pending.content, identity, condition);
+                return true;
+            }
+            const remote = await this.readOwnershipFresh(aid);
+            const fail = (code, reason, retryable = false) => ownershipFailure(code, reason, 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 || first !== null && second !== null && typeof first === 'object' && typeof second === 'object' && ['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 = this.saveRecord(aid, { content: pending.content, remote_etag: remote.etag, 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 ownershipFailure('conflict', 'pending agent.md original document condition changed');
+            const identity = signer ?? this._currentAid();
+            if (!identity)
+                throw new StateError('pending agent.md requires a signer identity');
+            verifyAgentMdUpload(pending.content, identity.certPem, aid);
+            await this._uploadPrepared(aid, pending.content, identity, condition);
+            return true;
+        }
+        catch (error) {
+            this.saveRecord(aid, { pending_error: error instanceof Error ? error.message : String(error) });
+            throw error;
+        }
+    }
+    async _uploadPrepared(target, signedContent, signer, originalCondition) {
+        const meta = validateAgentMdDocument(signedContent, { expectedAid: target }).frontmatter;
+        const entity = ['group', 'org'].includes(String(meta.type));
+        const entityContext = entity ? await this._entityContext(target, meta, signer) : undefined;
+        let condition = originalCondition;
+        let relation = entityContext ?? (this.pendingUpload(target))?.relation;
+        if (!condition) {
+            const fresh = entity ? await this._readEntityFresh(target) : await this.readOwnershipFresh(target);
+            condition = fresh.exists ? { if_match: fresh.etag } : { if_none_match: '*' };
+            if (!entity) {
+                const authority = fresh;
+                const candidate = parseOwnershipFile(signedContent, 'agent', { expectedSubAid: target });
+                const statement = fresh.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 };
+            }
+        }
+        const uploader = this._currentAid();
+        const entityOwnerUpload = entity && uploader.aid.toLowerCase() !== target.toLowerCase();
+        const entityAuthorization = entityOwnerUpload ? originalCondition ? (this.pendingUpload(target))?.authorization : this._ownerUploadAuthorization(target, signedContent, uploader, String(entityContext.entity_cert_fingerprint)) : '';
+        if (entityOwnerUpload) {
+            const timestamp = this._validateEntityUploadAuthorization(entityAuthorization, target, signedContent, uploader, String(entityContext.entity_cert_fingerprint));
+            if (Math.abs(Math.floor(Date.now() / 1000) - timestamp) > 300)
+                throw ownershipFailure('conflict', 'pending entity V2 authorization expired; explicit upload is required');
+        }
+        const pending = this.saveRecord(target, { pending_operation: 'replace', pending_target_aid: target, pending_content: signedContent, pending_content_etag: AgentMdManager.contentEtag(signedContent), pending_error: '', pending_condition: condition, pending_relation: relation, pending_authorization: entityAuthorization });
+        const savedCondition = pending.pending_condition;
+        if (pending.pending_content !== signedContent || 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 ? entityAuthorization : delegated ? this._ownerUploadAuthorization(target, signedContent, owner) : '';
+            const result = await this._uploadHttp(target, signedContent, authorization, condition);
+            const remoteEtag = String(result.etag ?? '').trim();
+            const saved = this.saveRecord(target, {
+                content: signedContent, local_etag: AgentMdManager.contentEtag(signedContent), 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: '',
+                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) {
+            this.saveRecord(target, { pending_error: error instanceof Error ? error.message : String(error) });
+            throw error;
+        }
+    }
+    async _readEntityFresh(target) {
+        const gateway = await this._resolveGateway(target);
+        const headers = { 'Cache-Control': 'no-cache', ...(this._uploadViaGatewayHost ? { Host: target } : {}) };
+        const request = (url) => requestText(url, { method: 'GET', verifySsl: this._verifySsl, headers, timeoutMs: DEFAULT_HTTP_TIMEOUT_MS, redirectsLeft: 0, strictUtf8: true });
+        const response = await request(this._url(target, gateway, this._uploadViaGatewayHost));
+        if (response.status !== 200 && response.status !== 404)
+            throw ownershipFailure('unavailable', `entity agent.md fresh read failed: HTTP ${response.status}`, true);
+        if (headerValue(response.headers, 'X-AUN-Ownership-Status') !== 'not_applicable' || !['current', 'stale'].includes(headerValue(response.headers, 'X-AUN-Entity-Verification-Status')))
+            throw ownershipFailure('unavailable', 'entity authority status metadata is unavailable', true);
+        const etag = headerValue(response.headers, 'ETag');
+        if (response.status === 200 && !etag)
+            throw ownershipFailure('unavailable', 'entity agent.md fresh read has no ETag', true);
+        return { exists: response.status === 200, content: response.status === 200 ? response.text : '', etag, owner_aid: headerValue(response.headers, 'X-AUN-Entity-Owner-AID'), entity_cert_fingerprint: headerValue(response.headers, 'X-AUN-Entity-Cert-Fingerprint') };
+    }
+    async readEntityAuthorityFresh(target) {
+        const observed = await this._readEntityFresh(this.safeAid(target));
+        if (!observed.owner_aid || !/^sha256:[0-9a-f]{64}$/.test(observed.entity_cert_fingerprint))
+            throw ownershipFailure('unavailable', 'entity owner authority metadata is unavailable', true);
+        return { owner_aid: observed.owner_aid, entity_cert_fingerprint: observed.entity_cert_fingerprint };
+    }
+    async _entityContext(target, meta, signer) {
+        const owner = String(meta.owner ?? '').trim().toLowerCase();
+        const uploader = this._currentAid();
+        if (![owner, target.toLowerCase()].includes(signer.aid.toLowerCase()) || !uploader || ![owner, target.toLowerCase()].includes(uploader.aid.toLowerCase()) || uploader.aid.toLowerCase() !== this._ownerAid().toLowerCase())
+            throw ownershipFailure('forbidden', 'group/org agent.md requires entity or current owner identity');
+        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 ownershipFailure('conflict', 'entity signing certificate changed');
+        if (uploader.aid.toLowerCase() === target.toLowerCase()) {
+            if (uploader.certFingerprint !== context.entity_cert_fingerprint)
+                throw ownershipFailure('conflict', 'entity uploader certificate changed');
+        }
+        else if (uploader.certFingerprint !== signer.certFingerprint)
+            await this._verifyEntityOwnerSigner(uploader);
+        return context;
+    }
+    async _entitySigningIdentity(target, meta, signature, candidate) {
+        const signer = signature.signer_aid ?? target;
+        if (candidate?.aid === signer && candidate.certFingerprint === signature.cert_fingerprint)
+            return candidate;
+        if (signer === target)
+            return await this._entityIdentityGetter?.(target, String(meta.type)) ?? await this._resolvePeer(target);
+        if (!this._entitySignerResolver)
+            throw ownershipFailure('unavailable', 'entity owner signing certificate resolver is unavailable', true);
+        return await this._entitySignerResolver(signer, signature.cert_fingerprint);
+    }
+    async _verifyEntityOwnerSigner(owner) {
+        if (!this._entitySignerResolver)
+            throw ownershipFailure('unavailable', 'entity owner signing certificate resolver is unavailable', true);
+        const fresh = await this._entitySignerResolver(owner.aid, owner.certFingerprint);
+        if (fresh.aid.toLowerCase() !== owner.aid.toLowerCase() || fresh.certFingerprint !== owner.certFingerprint) {
+            throw ownershipFailure('conflict', 'entity owner signing certificate changed');
+        }
+    }
+    async _entityCurrentContext(target, meta, uploading = false) {
+        const owner = String(meta.owner ?? '').trim().toLowerCase();
+        const observed = this._entityOwnerResolver ? null : await this._readEntityFresh(target);
+        if (observed && !/^sha256:[0-9a-f]{64}$/.test(observed.entity_cert_fingerprint))
+            throw ownershipFailure('unavailable', 'entity authority metadata is unavailable', true);
+        const freshOwner = String(this._entityOwnerResolver ? await this._entityOwnerResolver(target, String(meta.type)) : observed?.owner_aid).trim().toLowerCase();
+        if (!freshOwner)
+            throw ownershipFailure('unavailable', 'entity current owner is unavailable', true);
+        if (freshOwner !== owner)
+            throw ownershipFailure(uploading ? 'forbidden' : 'conflict', 'entity current owner changed');
+        const entity = await this._entityIdentityGetter?.(target, String(meta.type)) ?? await this._resolvePeer(target);
+        if (!entity.certFingerprint)
+            throw ownershipFailure('unavailable', 'entity current certificate is unavailable', true);
+        if (observed && observed.entity_cert_fingerprint !== entity.certFingerprint)
+            throw ownershipFailure('conflict', 'entity authority changed during verification');
+        if (meta.entity_cert_fingerprint !== entity.certFingerprint)
+            throw ownershipFailure('conflict', 'entity agent.md certificate generation changed');
+        return { type: meta.type, owner_aid: owner, entity_cert_fingerprint: entity.certFingerprint };
+    }
+    _validateEntityUploadAuthorization(authorization, target, content, owner, entityFingerprint) {
+        const invalid = ownershipFailure('persistence_unavailable', 'pending entity original V2 authorization is missing or invalid');
+        try {
+            if (typeof authorization !== 'string' || !/^[A-Za-z0-9_-]+={0,2}$/.test(authorization) || authorization.includes('=') && authorization.length % 4 !== 0)
+                throw invalid;
+            const raw = Buffer.from(authorization, 'base64url');
+            if (raw.toString('base64url') !== authorization.replace(/=+$/, ''))
+                throw invalid;
+            const text = new TextDecoder('utf-8', { fatal: true }).decode(raw);
+            const value = JSON.parse(text);
+            const lexical = parseDocument(text, { uniqueKeys: true });
+            if (lexical.errors.length || lexical.get('version', true)?.source !== '2' || !/^[1-9][0-9]*$/.test(lexical.get('timestamp', true)?.source ?? ''))
+                throw invalid;
+            const fields = ['version', 'target_aid', 'uploader_aid', 'body_sha256', 'entity_cert_fingerprint', 'timestamp', 'nonce', 'cert_fingerprint', 'signature'];
+            if (!isJsonObject(value) || Object.keys(value).length !== fields.length || fields.some(field => !(field in value)) || value.version !== 2)
+                throw invalid;
+            const timestamp = value.timestamp, nonce = value.nonce;
+            if (typeof timestamp !== 'number' || !Number.isSafeInteger(timestamp) || timestamp <= 0 || typeof nonce !== 'string' || !nonce.trim() || Buffer.byteLength(nonce, 'utf8') > 128)
+                throw invalid;
+            if (value.target_aid !== target.toLowerCase() || value.uploader_aid !== owner.aid.toLowerCase() || value.body_sha256 !== crypto.createHash('sha256').update(content, 'utf-8').digest('hex') || value.entity_cert_fingerprint !== entityFingerprint || value.cert_fingerprint !== owner.certFingerprint || typeof value.signature !== 'string')
+                throw invalid;
+            const verified = owner.verify(`AUN-AGENTMD-OWNER-AUTH-V2;${value.uploader_aid};${value.target_aid};${value.body_sha256};${entityFingerprint};${timestamp};${nonce}`, value.signature);
+            if (!verified.ok || !verified.data?.valid)
+                throw invalid;
+            return timestamp;
+        }
+        catch {
+            throw invalid;
+        }
+    }
+    _ownerUploadAuthorization(target, signedContent, owner, entityFingerprint = '') {
+        const bodySha256 = crypto.createHash('sha256').update(signedContent, 'utf-8').digest('hex');
+        const timestamp = Math.floor(Date.now() / 1000);
+        const nonce = crypto.randomBytes(16).toString('hex');
+        const canonical = entityFingerprint ? `AUN-AGENTMD-OWNER-AUTH-V2;${owner.aid.toLowerCase()};${target.toLowerCase()};${bodySha256};${entityFingerprint};${timestamp};${nonce}` : `AUN-AGENT-MD-UPLOAD-V1;${owner.aid.toLowerCase()};${target.toLowerCase()};${bodySha256};${timestamp};${nonce}`;
+        const signed = owner.sign(canonical);
+        if (!signed.ok || !signed.data) {
+            const message = signed.error?.message ?? 'owner authorization signing failed';
+            throw new ClientSignatureError(message);
+        }
+        const payload = {
+            version: entityFingerprint ? 2 : 1,
+            target_aid: target.toLowerCase(),
+            uploader_aid: owner.aid.toLowerCase(),
+            body_sha256: bodySha256,
+            ...(entityFingerprint ? { entity_cert_fingerprint: entityFingerprint } : {}),
+            timestamp,
+            nonce,
+            cert_fingerprint: owner.certFingerprint,
+            signature: signed.data.signature,
+        };
+        return Buffer.from(JSON.stringify(payload)).toString('base64url');
+    }
+    async _uploadHttp(target, signedContent, ownerAuthorization = '', condition) {
+        if (!condition || Object.keys(condition).length !== 1 || !(typeof condition.if_match === 'string' && condition.if_match || condition.if_none_match === '*'))
+            throw ownershipFailure('persistence_unavailable', 'agent.md upload requires its original document condition');
+        const gatewayUrl = await this._resolveGateway(target);
+        const authorization = String(ownerAuthorization ?? '').trim();
+        const entity = ['group', 'org'].includes(String(validateAgentMdDocument(signedContent, { expectedAid: target }).frontmatter.type));
         const uploadHeaders = {
-            Authorization: `Bearer ${token}`,
             'Content-Type': 'text/markdown; charset=utf-8',
+            ...(!entity ? { 'X-AUN-Ownership-Check': '1' } : {}),
+            ...(condition.if_match ? { 'If-Match': condition.if_match } : { 'If-None-Match': '*' }),
             ...(this._uploadViaGatewayHost ? { Host: target } : {}),
+            ...(authorization ? { [entity ? 'AUN-AGENTMD-OWNER-AUTHORIZATION' : 'X-AUN-AgentMD-Owner-Authorization']: authorization } : {}),
         };
+        if (!authorization || entity) {
+            const token = await this._uploadAccessToken(entity ? this._ownerAid() : target, gatewayUrl);
+            uploadHeaders.Authorization = `Bearer ${token}`;
+        }
         const uploadRequest = (url) => requestText(url, {
             method: 'PUT',
             verifySsl: this._verifySsl,
@@ -327,11 +748,12 @@ export class AgentMdManager {
             if (fallbackUrl && fallbackUrl !== uploadUrl)
                 response = await uploadRequest(fallbackUrl);
         }
-        if (response.status === 404) {
+        if (response.status === 404)
             throw new NotFoundError(`agent.md endpoint not found for aid: ${target}`);
-        }
         if (response.status < 200 || response.status >= 300) {
             const message = response.text.trim();
+            if (entity)
+                throw ownershipFailure(response.status === 409 || response.status === 412 ? 'conflict' : response.status === 401 || response.status === 403 ? 'forbidden' : response.status === 400 || response.status === 422 ? 'invalid' : response.status === 428 ? 'unsupported_protocol' : 'unavailable', `upload agent.md failed: HTTP ${response.status}${message ? ` - ${message}` : ''}`, response.status >= 500);
             throw new AUNError(`upload agent.md failed: HTTP ${response.status}${message ? ` - ${message}` : ''}`);
         }
         let payload;
@@ -341,21 +763,9 @@ export class AgentMdManager {
         catch (err) {
             throw new AUNError(`upload agent.md returned invalid JSON payload: ${err instanceof Error ? err.message : String(err)}`);
         }
-        if (!isJsonObject(payload)) {
+        if (!isJsonObject(payload))
             throw new AUNError('upload agent.md returned invalid JSON payload');
-        }
-        const result = payload;
-        this.saveRecord(target, {
-            content: signedContent,
-            local_etag: AgentMdManager.contentEtag(signedContent),
-            remote_etag: String(result.etag ?? '').trim() || undefined,
-            last_modified: String(result.last_modified ?? result.lastModified ?? '').trim(),
-            fetched_at: Date.now(),
-            checked_at: Date.now(),
-            remote_status: String(result.etag ?? '').trim() ? 'found' : 'unknown',
-            last_error: '',
-        });
-        return { ...result };
+        return { ...payload };
     }
     async download(aid, timeoutMs = DEFAULT_HTTP_TIMEOUT_MS) {
         const target = this.safeAid(String(aid ?? this._ownerAid() ?? '').trim());
@@ -574,14 +984,14 @@ export class AgentMdManager {
     async _resolveGateway(aid) {
         return String(await this._gatewayResolver?.(aid) ?? '');
     }
-    async _resolvePeer(aid, certFingerprint) {
+    async _resolvePeer(aid, certFingerprint, signedAt) {
         const expectedFp = String(certFingerprint ?? '').trim().toLowerCase();
         const current = this._currentAid();
         if (current && current.aid.toLowerCase() === aid.toLowerCase()) {
             if (!expectedFp || 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}`);
         }
@@ -593,6 +1003,13 @@ 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 _head(aid) {
         const target = this.safeAid(aid);
         const gatewayUrl = await this._resolveGateway(target);
@@ -645,6 +1062,7 @@ export class AgentMdManager {
             verifySsl: this._verifySsl,
             headers,
             timeoutMs,
+            strictUtf8: true,
         });
         let reusedCachedNotModified = false;
         if (response.status === 304 && cached.content !== undefined && cached.content !== null) {
@@ -665,6 +1083,7 @@ export class AgentMdManager {
                 verifySsl: this._verifySsl,
                 headers: { Accept: 'text/markdown' },
                 timeoutMs,
+                strictUtf8: true,
             });
         }
         if (response.status === 404) {
@@ -676,9 +1095,28 @@ export class AgentMdManager {
             throw new AUNError(`download agent.md failed: HTTP ${response.status}${message ? ` - ${message}` : ''}`);
         }
         const content = response.text;
+        if (headerValue(response.headers, 'X-AUN-Entity-Verification-Status') === 'stale')
+            throw ownershipFailure('conflict', 'entity agent.md is not from the current lifecycle generation');
         const parsed = parseAgentMdTailSignature(content);
+        let entity = false;
+        let frontmatter = {};
+        try {
+            frontmatter = parseFileFrontmatter(parsed.payload);
+            entity = ['group', 'org'].includes(String(frontmatter.type));
+        }
+        catch { }
+        if (entity) {
+            try {
+                frontmatter = validateAgentMdDocument(content, { expectedAid: target, validateOwnership: false, requireSignature: true }).frontmatter;
+            }
+            catch (error) {
+                throw ownershipFailure('invalid', error instanceof Error ? error.message : String(error));
+            }
+        }
+        if (entity)
+            await this._entityCurrentContext(target, frontmatter);
         const expectedFp = parsed.fields?.cert_fingerprint || parsed.fields?.public_key_fingerprint || null;
-        const peer = await this._resolvePeer(target, expectedFp);
+        const peer = entity ? await this._entitySigningIdentity(target, frontmatter, parsed.fields) : await this._resolvePeer(target, expectedFp, parsed.fields?.timestamp ? Number(parsed.fields.timestamp) : undefined);
         const verified = peer.verifyAgentMd(content);
         if (!verified.ok || !verified.data) {
             const message = verified.error?.message ?? 'agent.md verification failed';
@@ -688,9 +1126,33 @@ export class AgentMdManager {
         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' } : {});
+        }
+        if (!entity)
+            frontmatter = validateAgentMdDocument(content, { expectedAid: target, validateOwnership: false }).frontmatter;
+        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 subjectStatement = subjectSignature?.statement;
+                const subjectCertPem = subjectSignature ? (await this._resolvePeer(target, String(subjectSignature.cert_fingerprint), isJsonObject(subjectStatement) ? Number(subjectStatement.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 = verifyOwnershipFrontmatterStatus(frontmatter, subjectCertPem, ownerCertPem);
+            }
+            catch {
+                ownershipStatus = 'invalid';
+            }
         }
-        const verification = { status: statusText };
+        const verification = { status: statusText, ownership_status: ownershipStatus };
         if (reason)
             verification.reason = reason;
         const responseEtag = headerValue(response.headers, 'etag');