@agentunion/fastaun-browser 0.5.19 → 0.5.21

package/dist/ownership-v21.js

@@ -1,5 +1,5 @@
 import { parseFileFrontmatter, validateAgentMdCertificate, validateAgentMdDocument } from './agent-md-schema.js';
-import { buildAgentMdSignatureBlock, certFingerprint, isStrictBase64, parseAgentMdTailSignature, publicKeyFingerprint, publicKeyMatchesFingerprint, signBytes, verifySignatureWithCert } from './cert-utils.js';
+import { signDocument, verifyDocument, isStrictBase64, parseAgentMdTailSignature } from './cert-utils.js';
 import { base64ToUint8 } from './crypto.js';
 import { StateError, ValidationError } from './errors.js';
 import { buildDefaultAgentMd, buildOwnershipAgentMdV21 } from './agent-md.js';
@@ -108,7 +108,9 @@ export function parseOwnershipFile(content, role, context = {}) {
     if (raw.length - new TextEncoder().encode(parsed.payload).length > 2048)
         throw new ValidationError('ownership file signature exceeds 2048 bytes');
     const fields = parsed.fields;
-    if (fields) {
+    if (fields?.signer_aid !== undefined)
+        throw new ValidationError('ownership main signature contains unknown signer_aid');
+    for (const { fields } of parsed.signatures) {
         if (!/^sha256:[0-9a-f]{64}$/.test(fields.cert_fingerprint) || fields.public_key_fingerprint !== undefined && !/^sha256:[0-9a-f]{64}$/.test(fields.public_key_fingerprint))
             throw new ValidationError('ownership file fingerprint is invalid');
         if (!/^[1-9][0-9]*$/.test(fields.timestamp) || !Number.isSafeInteger(Number(fields.timestamp)))
@@ -121,7 +123,7 @@ export function parseOwnershipFile(content, role, context = {}) {
     let action;
     let transfer;
     if (role === 'agent') {
-        frontmatter = validateAgentMdDocument(text, { expectedAid: context.expectedSubAid, validateOwnership: false, now: context.now, checkTimestamp: false }).frontmatter;
+        frontmatter = validateAgentMdDocument(text, { expectedAid: context.expectedSubAid, validateOwnership: false, validateOwnershipNumbers: true, now: context.now, checkTimestamp: false }).frontmatter;
         requireOwnershipApplicable(frontmatter.type);
         statement = validateOwnershipAgentFrontmatter(frontmatter, context.expectedSubAid);
         if (context.expectedOwnerAid && statement?.owner_aid !== context.expectedOwnerAid)
@@ -154,7 +156,7 @@ export function parseOwnershipFile(content, role, context = {}) {
     }
     else
         throw new ValidationError('ownership file role is invalid');
-    return { raw, payload: parsed.payload, frontmatter, signature: fields, statement, action, transfer };
+    return { raw, payload: parsed.payload, frontmatter, signature: fields, signatures: parsed.signatures, statement, action, transfer };
 }
 export async function verifyOwnershipFile(content, role, certificate, context = {}) {
     const parsed = parseOwnershipFile(content, role, { ...context, requireSignature: true });
@@ -165,19 +167,20 @@ export async function verifyOwnershipFile(content, role, certificate, context =
     if (context.expectedTargetAid && context.expectedTargetAid !== sub || context.authenticatedAid && context.authenticatedAid !== signer || context.certificateAid && context.certificateAid !== signer || context.resourcePath && context.resourcePath !== `${signer}:/${storagePath}` || context.storagePath && context.storagePath !== storagePath)
         throw new ValidationError('ownership file resource or authenticated identity mismatch');
     const now = Math.trunc(context.now ?? Date.now() / 1000);
-    if (Number(fields.timestamp) > now + 300)
-        throw new ValidationError('ownership file timestamp is too far in the future');
-    if (certificate.chain_valid === false || certificate.revoked === true || typeof certificate.state === 'string' && certificate.state !== 'active_signing')
-        throw new ValidationError('ownership signing certificate is not currently verified and active_signing', { stringCode: 'invalid' });
-    if (certificate.chain_valid !== true || certificate.state !== 'active_signing' || certificate.revoked !== false || certificate.revocation_checked !== true || !Number.isSafeInteger(certificate.observed_at) || certificate.observed_at <= 0 || certificate.observed_at > now + 5 || certificate.observed_at < now - 30)
-        throw new StateError('ownership certificate current status is unavailable', { stringCode: 'unavailable', retryable: true });
-    validateAgentMdCertificate(certificate.cert_pem, signer, Number(fields.timestamp), now);
-    if (await certFingerprint(certificate.cert_pem) !== fields.cert_fingerprint)
-        throw new ValidationError('ownership certificate fingerprint mismatch');
-    if (fields.public_key_fingerprint && !await publicKeyMatchesFingerprint(certificate.cert_pem, fields.public_key_fingerprint))
-        throw new ValidationError('ownership public key fingerprint mismatch');
-    if (!await verifySignatureWithCert(certificate.cert_pem, fields.signature, new TextEncoder().encode(parsed.payload)))
-        throw new ValidationError('ownership file signature verification failed');
+    const verified = await verifyDocument(new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(parsed.raw), async (blockSigner, fingerprint, timestamp) => {
+        const material = blockSigner === signer && fingerprint === fields.cert_fingerprint ? certificate : context.certificateResolver ? await context.certificateResolver(blockSigner, fingerprint) : null;
+        if (!material)
+            throw new StateError('ownership additional signing certificate is unavailable', { stringCode: 'unavailable', retryable: true });
+        if (material.chain_valid === false || material.revoked === true || typeof material.state === 'string' && material.state !== 'active_signing')
+            throw new ValidationError('ownership signing certificate is not currently verified and active_signing', { stringCode: 'invalid' });
+        if (material.chain_valid !== true || material.state !== 'active_signing' || material.revoked !== false || material.revocation_checked !== true || !Number.isSafeInteger(material.observed_at) || material.observed_at <= 0 || material.observed_at > now + 5 || material.observed_at < now - 30)
+            throw new StateError('ownership certificate current status is unavailable', { stringCode: 'unavailable', retryable: true });
+        validateAgentMdCertificate(material.cert_pem, blockSigner, timestamp, now);
+        return material.cert_pem;
+    }, { expectedAid: signer, now, requireCurrentValidity: true });
+    if (!verified.valid) {
+        throw new ValidationError(verified.reason || 'ownership file signature verification failed');
+    }
     return parsed;
 }
 export async function signOwnershipFile(identity, content, role, context = {}) {
@@ -193,8 +196,7 @@ export async function signOwnershipFile(identity, content, role, context = {}) {
         throw new ValidationError('ownership payload must end with a newline before signature');
     const now = Math.trunc(context.now ?? Date.now() / 1000);
     validateAgentMdCertificate(identity.certPem, identity.aid, now, now);
-    const signature = await signBytes(identity.privateKeyPem, new TextEncoder().encode(parsed.payload));
-    return parsed.payload + buildAgentMdSignatureBlock(identity.certFingerprint, now, signature, await publicKeyFingerprint(identity.certPem), role === 'agent' ? 'AUN-SIGNATURE-AGENTMD-V2' : 'AUN-SIGNATURE-OWNERSHIP-V2');
+    return (await signDocument(identity, parsed.payload, { now, tag: role === 'agent' ? 'AGENTMD-V2' : 'OWNERSHIP-V2' })).signed;
 }
 export async function ownershipSha256(content) {
     const bytes = typeof content === 'string' ? new TextEncoder().encode(content) : content;
@@ -219,9 +221,9 @@ export class OwnershipStorageAdapter {
         }
         catch (error) {
             if (error instanceof StateError && error.stringCode)
-                throw error;
+                throw error.stringCode === 'forbidden' && (method === 'storage.head_object' || method === 'storage.get_object') ? this.error('unavailable', error.message) : error;
             const code = error?.code;
-            throw this.error(code === -32009 ? 'conflict' : code === -32004 ? 'forbidden' : code === -32601 || code === -32602 ? 'unsupported_protocol' : 'unavailable', `Storage ownership request failed: ${String(error)}`);
+            throw this.error(code === -32009 ? 'conflict' : code === -32004 ? method === 'storage.head_object' || method === 'storage.get_object' ? 'unavailable' : 'forbidden' : code === -32601 ? 'unsupported_protocol' : code === -32602 ? 'invalid' : 'unavailable', `Storage ownership request failed: ${String(error)}`);
         }
     }
     metadata(value, ownerAid, path) {
@@ -230,13 +232,13 @@ export class OwnershipStorageAdapter {
         const service = `st.${ownerAid.slice(ownerAid.indexOf('.') + 1)}`;
         if (Object.hasOwn(value, 'service_aid') && value.service_aid !== service || Object.hasOwn(value, 'authenticated_service_aid') && value.authenticated_service_aid !== service)
             throw this.error('unavailable', 'Storage authoritative service identity unavailable');
-        if (value.consistency !== 'authoritative' || Object.hasOwn(value, 'recovery_ready') && value.recovery_ready !== true || value.owner_aid !== ownerAid || value.bucket !== 'default' || value.path !== path || typeof value.exists !== 'boolean' || typeof value.revision !== 'string' || !value.revision || !Number.isSafeInteger(observed) || observed < now - 30 || observed > now + 5 || observed <= 0)
-            throw this.error('unavailable', 'Storage authoritative namespace, revision or freshness unavailable');
-        if (value.exists && (typeof value.sha256 !== 'string' || !/^[0-9a-f]{64}$/.test(value.sha256) || typeof value.object_id !== 'string' || !value.object_id || !Number.isSafeInteger(value.version) || Number(value.version) <= 0))
+        if (value.consistency !== 'authoritative' || Object.hasOwn(value, 'recovery_ready') && value.recovery_ready !== true || value.owner_aid !== ownerAid || value.bucket !== 'default' || value.path !== path || typeof value.exists !== 'boolean' || !Number.isSafeInteger(observed) || observed < now - 30 || observed > now + 5 || observed <= 0)
+            throw this.error('unavailable', 'Storage authoritative namespace or freshness unavailable');
+        if (value.exists && (typeof value.sha256 !== 'string' || !/^[0-9a-f]{64}$/.test(value.sha256)))
             throw this.error('unavailable', 'Storage authoritative object metadata unavailable');
-        return { owner_aid: ownerAid, bucket: 'default', path, exists: value.exists, revision: value.revision,
+        return { owner_aid: ownerAid, bucket: 'default', path, exists: value.exists,
             observed_at: observed, sha256: value.exists ? String(value.sha256) : '', content: '', authoritative: true,
-            service_aid: service, authenticated_service_aid: service };
+            service_aid: service, authenticated_service_aid: service, version: value.exists && Number.isSafeInteger(value.version) && Number(value.version) > 0 ? Number(value.version) : undefined, ...(typeof value.revision === 'string' && value.revision ? { revision: value.revision } : {}) };
     }
     async readFile(ownerAid, path) {
         ownershipAid(ownerAid, 'owner_aid');
@@ -246,10 +248,10 @@ export class OwnershipStorageAdapter {
         const before = this.metadata(beforeRaw, ownerAid, path);
         if (!before.exists)
             return before;
-        const body = await this.request('storage.get_object', { ...params, expected_revision: before.revision });
+        const body = await this.request('storage.get_object', params);
         const current = this.metadata(body, ownerAid, path);
-        if (!current.exists || current.revision !== before.revision || current.sha256 !== before.sha256 || body.object_id !== beforeRaw.object_id || body.version !== beforeRaw.version)
-            throw this.error('unavailable', 'Storage ownership body revision changed');
+        if (!current.exists || current.sha256 !== before.sha256 || before.revision !== undefined && current.revision !== before.revision)
+            throw this.error('unavailable', 'Storage ownership body changed');
         if (typeof body.content !== 'string')
             throw this.error('unavailable', 'Storage ownership body is unavailable');
         if (body.content !== '' && !isStrictBase64(body.content))
@@ -266,34 +268,56 @@ export class OwnershipStorageAdapter {
         }
         const afterRaw = await this.request('storage.head_object', params);
         const after = this.metadata(afterRaw, ownerAid, path);
-        if (!after.exists || after.revision !== before.revision || after.sha256 !== before.sha256 || afterRaw.object_id !== beforeRaw.object_id || afterRaw.version !== beforeRaw.version || Math.trunc(this.deps.now?.() ?? Date.now() / 1000) - began > 30)
+        if (!after.exists || after.sha256 !== before.sha256 || before.revision !== undefined && after.revision !== before.revision || Math.trunc(this.deps.now?.() ?? Date.now() / 1000) - began > 30)
             throw this.error('unavailable', 'Storage ownership changed during authoritative read');
         return { ...after, content };
     }
     async readOwnerMd(ownerAid, subAid) {
         return await this.readFile(ownerAid, `sub_aids/${ownershipAid(subAid, 'sub_aid')}/owner.md`);
     }
-    async writeOwnerMd(ownerAid, subAid, raw, expectedRevision) {
+    async writeOwnerMd(ownerAid, subAid, raw, original, guard) {
         if (ownerAid !== this.deps.currentAid())
             throw this.error('forbidden', 'only the authenticated owner may publish owner.md');
-        if (typeof expectedRevision !== 'string' || !expectedRevision)
-            throw this.error('invalid', 'ownership expected_revision is required');
+        const path = `sub_aids/${ownershipAid(subAid, 'sub_aid')}/owner.md`;
+        const before = await this.readOwnerMd(ownerAid, subAid);
+        if (original && (before.exists !== original.exists || before.content !== original.content || before.sha256 !== original.sha256 || original.revision !== undefined && before.revision !== original.revision))
+            throw this.error('conflict', 'ownership original owner file was replaced');
         const bytes = new TextEncoder().encode(raw);
-        let binary = '';
-        for (const byte of bytes)
-            binary += String.fromCharCode(byte);
-        await this.request('storage.put_object', { owner_aid: ownershipAid(ownerAid, 'owner_aid'), bucket: 'default', object_key: `sub_aids/${ownershipAid(subAid, 'sub_aid')}/owner.md`, content: btoa(binary), content_type: 'text/markdown', is_private: false, overwrite: true, expected_revision: expectedRevision });
+        const expectedVersion = before.exists ? (original ?? before).version : 0;
+        if (typeof expectedVersion !== 'number' || !Number.isSafeInteger(expectedVersion) || expectedVersion < (before.exists ? 1 : 0))
+            throw this.error('unavailable', 'Storage owner.md version is unavailable');
+        await guard?.();
+        const session = await this.request('storage.create_upload_session', { owner_aid: ownershipAid(ownerAid, 'owner_aid'), bucket: 'default', object_key: path, size_bytes: bytes.length, content_type: 'text/markdown; charset=utf-8', expected_version: expectedVersion, overwrite: true });
+        const uploadURL = String(session.upload_url ?? ''), sessionID = String(session.session_id ?? '');
+        if (!uploadURL || !sessionID)
+            throw this.error('unavailable', 'Storage owner.md upload session is incomplete');
+        const headers = {};
+        if (session.headers && typeof session.headers === 'object')
+            for (const [key, value] of Object.entries(session.headers))
+                if (value !== undefined && value !== null && key.toLowerCase() !== 'content-type')
+                    headers[key] = String(value);
+        headers['Content-Type'] = 'text/markdown; charset=utf-8';
+        await guard?.();
+        if (this.deps.httpPut)
+            await this.deps.httpPut(uploadURL, bytes, headers);
+        else {
+            const response = await fetch(uploadURL, { method: 'PUT', body: bytes, headers });
+            if (!response.ok)
+                throw this.error('unavailable', `Storage owner.md HTTP PUT failed: ${response.status}`);
+        }
+        const complete = { owner_aid: ownerAid, bucket: 'default', object_key: path, session_id: sessionID, size_bytes: bytes.length, sha256: await ownershipSha256(bytes), content_type: 'text/markdown; charset=utf-8', is_private: false, overwrite: true };
+        complete.expected_version = expectedVersion;
+        await guard?.();
+        await this.request('storage.complete_upload', complete);
         return await this.readOwnerMd(ownerAid, subAid);
     }
-    async deleteOwnerMd(ownerAid, subAid, expectedRevision) {
+    async deleteOwnerMd(ownerAid, subAid) {
         if (ownerAid !== this.deps.currentAid())
             throw this.error('forbidden', 'only the authenticated owner may delete owner.md');
-        if (typeof expectedRevision !== 'string' || !expectedRevision)
-            throw this.error('invalid', 'ownership expected_revision is required');
         const path = `sub_aids/${ownershipAid(subAid, 'sub_aid')}/owner.md`;
-        await this.request('storage.delete_object', { owner_aid: ownershipAid(ownerAid, 'owner_aid'), bucket: 'default', object_key: path, expected_revision: expectedRevision });
+        await this.request('storage.delete_object', { owner_aid: ownershipAid(ownerAid, 'owner_aid'), bucket: 'default', object_key: path });
         const after = this.metadata(await this.request('storage.head_object', { owner_aid: ownerAid, bucket: 'default', object_key: path, consistency: 'authoritative' }), ownerAid, path);
-        if (after.exists || after.revision === expectedRevision)
+        if (after.exists)
             throw this.error('conflict', 'Storage ownership deletion could not be confirmed');
     }
 }
@@ -318,12 +342,12 @@ export class OwnershipFiles {
         if (snapshot.sub_aid !== subAid || Object.hasOwn(snapshot, 'recovery_ready') && snapshot.recovery_ready !== true || !['locked', 'unlocked'].includes(snapshot.lock) || typeof snapshot.exists !== 'boolean' || !Number.isSafeInteger(snapshot.relation_version) || snapshot.relation_version < 0)
             throw new StateError('NS ownership 2.1 authoritative metadata is unavailable', { stringCode: 'unavailable', retryable: true });
         if (snapshot.exists && !snapshot.etag || !snapshot.exists && (snapshot.lock !== 'unlocked' || snapshot.relation_version !== 0))
-            throw new StateError('NS ownership document or ledger is unavailable');
+            throw new StateError('NS ownership document metadata is unavailable');
         this.fresh(snapshot.observed_at);
     }
     async validateOwnerSnapshot(snapshot, ownerAid, subAid) {
         const expectedService = `st.${ownerAid.slice(ownerAid.indexOf('.') + 1)}`;
-        if (snapshot.error || snapshot.authoritative !== true || Object.hasOwn(snapshot, 'recovery_ready') && snapshot.recovery_ready !== true || snapshot.owner_aid !== ownerAid || snapshot.bucket !== 'default' || snapshot.path !== `sub_aids/${subAid}/owner.md` || snapshot.service_aid !== expectedService || snapshot.authenticated_service_aid !== expectedService || typeof snapshot.revision !== 'string' || !snapshot.revision || typeof snapshot.exists !== 'boolean')
+        if (snapshot.error || snapshot.authoritative !== true || Object.hasOwn(snapshot, 'recovery_ready') && snapshot.recovery_ready !== true || snapshot.owner_aid !== ownerAid || snapshot.bucket !== 'default' || snapshot.path !== `sub_aids/${subAid}/owner.md` || snapshot.service_aid !== expectedService || snapshot.authenticated_service_aid !== expectedService || typeof snapshot.exists !== 'boolean')
             throw new StateError('Storage authoritative ownership object is unavailable');
         this.fresh(snapshot.observed_at);
         if (snapshot.exists && (!/^[0-9a-f]{64}$/.test(snapshot.sha256) || await ownershipSha256(snapshot.content) !== snapshot.sha256))
@@ -353,36 +377,42 @@ export class OwnershipFiles {
         const file = parseOwnershipFile(content, role, { expectedSubAid: subAid, expectedOwnerAid: role === 'owner' ? ownerAid : undefined, now: this.now() });
         const signer = role === 'agent' ? subAid : ownerAid;
         const certificate = await this.deps.resolveCertificate(signer, file.signature.cert_fingerprint, role === 'agent' && file.frontmatter.type === 'group' ? 'group_identity' : undefined);
-        return await verifyOwnershipFile(content, role, certificate, { expectedSubAid: subAid, expectedOwnerAid: role === 'owner' ? ownerAid : undefined, certificateAid: signer, now: this.now() });
+        return await verifyOwnershipFile(content, role, certificate, { expectedSubAid: subAid, expectedOwnerAid: role === 'owner' ? ownerAid : undefined, certificateAid: signer, certificateResolver: (aid, fingerprint) => this.deps.resolveCertificate(aid, fingerprint), now: this.now() });
     }
     async checkConsensus(subAid = this.deps.currentAid().aid, pendingTarget) {
         const began = this.now();
-        const result = { status: 'unavailable', sub_aid: subAid, owner_aid: null, relation_version: 0, lock: 'unlocked', agent_md_etag: '', agent_md_sha256: '', owner_md_revision: '', owner_md_sha256: '' };
+        const result = { status: 'unavailable', sub_aid: subAid, owner_aid: null, relation_version: 0, lock: 'unlocked', agent_md_etag: '', agent_md_sha256: '', owner_md_sha256: '' };
         try {
             const first = await this.readAgent(subAid);
             Object.assign(result, { relation_version: first.relation_version, lock: first.lock, agent_md_etag: first.etag, agent_md_sha256: first.exists ? await ownershipSha256(first.content) : '' });
-            const released = first.lock === 'unlocked' && first.relation_version > 0;
-            const agent = !released && first.exists ? await this.verify(first.content, 'agent', subAid) : null;
-            if (first.lock === 'unlocked' && first.relation_version === 0 && agent?.statement)
+            const agent = first.exists ? await this.verify(first.content, 'agent', subAid) : null;
+            if ((agent?.statement?.relation_version ?? 0) !== first.relation_version)
                 throw new StateError('NS relation metadata does not match agent.md', { stringCode: 'unavailable', retryable: true });
-            const ownerAid = released ? undefined : agent?.statement?.owner_aid ?? pendingTarget?.owner_aid;
+            const ownerAid = agent?.statement?.owner_aid ?? pendingTarget?.owner_aid;
             let owner = null;
             let object = null;
             if (ownerAid) {
                 object = await this.readOwner(ownerAid, subAid);
-                result.owner_md_revision = object.revision;
                 result.owner_md_sha256 = object.exists ? object.sha256 : '';
+                result.owner_md = { owner_aid: ownerAid, bucket: 'default', path: `sub_aids/${subAid}/owner.md`, exists: object.exists, content: object.content, sha256: object.sha256, observed_at: object.observed_at };
                 if (object.exists)
                     owner = await this.verify(object.content, 'owner', subAid, ownerAid);
             }
             const last = await this.readAgent(subAid);
             if (last.relation_version !== first.relation_version || last.etag !== first.etag || last.lock !== first.lock || last.exists !== first.exists || last.owner_aid !== first.owner_aid || first.exists && await ownershipSha256(last.content) !== result.agent_md_sha256)
                 throw new StateError('NS ownership changed during verification');
+            if (object && ownerAid) {
+                const current = await this.readOwner(ownerAid, subAid);
+                if (current.exists !== object.exists || current.sha256 !== object.sha256 || current.content !== object.content)
+                    throw new StateError('Storage ownership changed during verification', { stringCode: 'unavailable', retryable: true });
+            }
             this.fresh(began);
             this.fresh(first.observed_at);
             if (object)
                 this.fresh(object.observed_at);
-            if (released) {
+            if (first.lock === 'unlocked' && agent?.statement) {
+                if (!object || object.exists && (!owner?.statement || owner.action !== 'release' || !ownershipStatementsMatch(agent.statement, owner.statement)))
+                    throw new StateError('current ownership files do not confirm release', { stringCode: 'unavailable', retryable: true });
                 result.status = 'released';
             }
             else if (first.lock === 'locked') {
@@ -425,14 +455,37 @@ export class OwnershipFiles {
         const snapshot = await this.readAgent(task.sub_aid);
         if (snapshot.relation_version !== task.base_relation_version || snapshot.lock !== (task.operation === 'bind' ? 'unlocked' : 'locked'))
             throw new StateError('ownership relation version conflict', { stringCode: 'ownership_conflict', retryable: false });
-        if (!snapshot.exists)
-            throw new StateError('initial agent.md is not published', { stringCode: 'unavailable', retryable: true });
+        if (!snapshot.exists) {
+            const base = task.base_agent_md;
+            if (task.operation !== 'bind' || base?.exists)
+                throw new StateError('ownership original resource is unavailable', { stringCode: 'conflict' });
+            if (!base) {
+                task.base_agent_md = { exists: false, raw: '', sha256: await ownershipSha256(''), etag: '', statement: null };
+                await task.persist();
+            }
+        }
         if (snapshot.exists) {
-            const file = task.operation === 'bind' && snapshot.relation_version > 0 ? parseOwnershipFile(snapshot.content, 'agent', { expectedSubAid: task.sub_aid }) : await this.verify(snapshot.content, 'agent', task.sub_aid);
+            const file = await this.verify(snapshot.content, 'agent', task.sub_aid);
+            const base = task.base_agent_md;
+            if (base && (base.exists !== snapshot.exists || (base.statement ? !file.statement || !['version', 'declaration_id', 'owner_aid', 'sub_aid', 'relation_version', 'declared_at'].every((key) => base.statement[key] === file.statement[key]) : file.statement || base.raw !== snapshot.content || base.etag !== snapshot.etag || base.sha256 !== await ownershipSha256(snapshot.content))))
+                throw new StateError('ownership original relation was replaced', { stringCode: 'conflict', retryable: false });
+            if (!base) {
+                task.base_agent_md = { exists: true, raw: snapshot.content, sha256: await ownershipSha256(snapshot.content), etag: snapshot.etag, statement: file.statement ?? null };
+                await task.persist();
+            }
             if (snapshot.lock === 'unlocked' && snapshot.relation_version === 0 && file.statement)
                 throw new StateError('NS relation metadata does not match agent.md', { stringCode: 'unavailable', retryable: true });
-            if (task.operation !== 'bind' && file.statement?.owner_aid !== task.owner_aid || task.operation === 'bind' && file.statement && file.statement.relation_version >= snapshot.relation_version)
+            if ((file.statement?.relation_version ?? 0) !== snapshot.relation_version || task.operation !== 'bind' && file.statement?.owner_aid !== task.owner_aid)
                 throw new StateError('ownership current owner mismatch', { stringCode: 'conflict', retryable: false });
+            if (task.operation === 'bind' && file.statement?.owner_aid === task.owner_aid)
+                throw new StateError('current owner release requires sub cleanup before binding again', { stringCode: 'conflict', retryable: false });
+            if (task.operation === 'bind' && base?.statement && task.base_owner_md) {
+                const original = await this.readOwner(base.statement.owner_aid, task.sub_aid), expected = task.base_owner_md;
+                if (original.exists !== expected.exists || original.content !== expected.raw || original.sha256 !== expected.sha256)
+                    throw new StateError('ownership original released owner file was replaced', { stringCode: 'conflict', retryable: false });
+            }
+            if (task.operation === 'bind' && file.statement && (await this.checkConsensus(task.sub_aid)).status !== 'released')
+                throw new StateError('current ownership files do not confirm release', { stringCode: 'unavailable', retryable: true });
         }
         return snapshot;
     }
@@ -444,6 +497,11 @@ export class OwnershipFiles {
         const file = await this.verify(object.content, 'owner', task.sub_aid, task.owner_aid);
         if (file.action !== 'transfer_owner' || file.statement?.relation_version !== task.base_relation_version || !file.transfer || file.transfer.new_owner_aid !== task.new_owner_aid || file.transfer.target_relation_version !== task.target_relation_version)
             throw new StateError('ownership transfer authorization target changed', { stringCode: 'conflict', retryable: false });
+        if (task.base_owner_md?.exists) {
+            const original = parseOwnershipFile(task.base_owner_md.raw, 'owner', { expectedSubAid: task.sub_aid, expectedOwnerAid: task.owner_aid }).statement;
+            if (!original || !['version', 'declaration_id', 'owner_aid', 'sub_aid', 'relation_version', 'declared_at'].every((key) => original[key] === file.statement[key]))
+                throw new StateError('ownership original transfer relation changed', { stringCode: 'conflict', retryable: false });
+        }
         if (file.transfer.expires_at <= this.now())
             throw new StateError('ownership transfer authorization expired', { stringCode: 'conflict', retryable: false });
         if (task.authorization_sha256 !== undefined && task.authorization_sha256 !== object.sha256 || task.expires_at !== undefined && task.expires_at !== file.transfer.expires_at)
@@ -460,42 +518,57 @@ export class OwnershipFiles {
         await this.readAgent(task.sub_aid);
         const current = await this.readOwner(ownerAid, task.sub_aid);
         let prepared = task.files[key];
+        if (!prepared && action !== 'declare' && !current.exists)
+            throw new StateError('ownership original owner file is unavailable', { stringCode: 'unavailable', retryable: true });
+        if (!prepared && !task.base_owner_md && action !== 'declare') {
+            const snapshot = current;
+            task.base_owner_md = { exists: snapshot.exists, raw: snapshot.content, sha256: snapshot.sha256 };
+            await task.persist();
+        }
         if (!prepared) {
             await this.requireBase(task);
+            const base = task.base_owner_md;
+            if (ownerAid === task.base_agent_md?.statement?.owner_aid && base && (current.exists !== base.exists || current.content !== base.raw || current.sha256 !== base.sha256))
+                throw new StateError('ownership original owner file was replaced', { stringCode: 'conflict', retryable: false });
             if (action === 'transfer_owner')
                 task.expires_at = this.now() + 3600;
-            const ownership = { statement: this.statement(ownerAid, task.sub_aid, version), action,
+            const original = action === 'declare' || !current.exists ? null : await this.verify(current.content, 'owner', task.sub_aid, ownerAid);
+            if (original && (!original.statement || original.statement.relation_version !== task.base_relation_version))
+                throw new StateError('ownership original owner relation changed', { stringCode: 'conflict', retryable: false });
+            const ownership = { statement: original?.statement ?? this.statement(ownerAid, task.sub_aid, version), action,
                 ...(action === 'transfer_owner' ? { transfer: { new_owner_aid: task.new_owner_aid, target_relation_version: task.target_relation_version, expires_at: task.expires_at } } : {}) };
             const payload = `---\nowner_aid: ${ownerAid}\nsub_aid: ${task.sub_aid}\nownership: ${JSON.stringify(ownership)}\n---\n`;
             const raw = await signOwnershipFile(identity, payload, 'owner', { now: this.now() });
             await this.verify(raw, 'owner', task.sub_aid, ownerAid);
-            prepared = { raw, sha256: await ownershipSha256(raw), condition: { expected_revision: current.revision } };
+            prepared = { raw, sha256: await ownershipSha256(raw), condition: {}, original_owner: { exists: current.exists, raw: current.content, sha256: current.sha256 } };
             if (action === 'transfer_owner')
                 prepared.expires_at = task.expires_at;
             task.files[key] = prepared;
             await task.persist();
         }
-        if (!prepared.condition || typeof prepared.condition.expected_revision !== 'string' || !prepared.condition.expected_revision)
-            throw new StateError('ownership original Storage revision is unavailable', { stringCode: 'ownership_conflict' });
+        if (!prepared.condition || Object.keys(prepared.condition).length !== 0 || !prepared.original_owner)
+            throw new StateError('ownership original owner.md context is unavailable', { stringCode: 'ownership_conflict' });
+        if (prepared.original_owner.revision && current.revision !== prepared.original_owner.revision)
+            throw new StateError('legacy owner original revision changed', { stringCode: 'conflict', retryable: false });
         if (current.exists && current.sha256 === prepared.sha256 && current.content === prepared.raw) {
-            if (prepared.published_revision !== undefined && prepared.published_revision !== current.revision)
-                throw new StateError('ownership published file revision changed', { stringCode: 'ownership_conflict' });
-            prepared.published_revision = current.revision;
-            await task.persist();
             return prepared;
         }
+        if (prepared.original_owner.exists && prepared.original_owner.raw === prepared.raw && prepared.original_owner.sha256 === prepared.sha256)
+            throw new StateError('ownership adopted owner file was replaced', { stringCode: 'conflict', retryable: false });
         await this.requireBase(task);
-        if (current.revision !== prepared.condition.expected_revision)
-            throw new StateError('ownership Storage revision conflict', { stringCode: 'ownership_conflict' });
         if (action === 'transfer_owner' && (!task.expires_at || task.expires_at <= this.now()))
             throw new StateError('ownership transfer authorization expired', { stringCode: 'conflict', retryable: false });
         await this.verify(prepared.raw, 'owner', task.sub_aid, ownerAid);
+        const latest = await this.readOwner(ownerAid, task.sub_aid), base = prepared.original_owner;
+        if (base.revision && latest.revision !== base.revision)
+            throw new StateError('legacy owner original revision changed before publication', { stringCode: 'conflict', retryable: false });
+        if (latest.exists !== base.exists || latest.content !== base.raw || latest.sha256 !== base.sha256)
+            throw new StateError('ownership original owner file was replaced', { stringCode: 'conflict', retryable: false });
         await task.guard?.();
-        await this.deps.writeOwnerMd(ownerAid, task.sub_aid, prepared.raw, prepared.condition.expected_revision);
+        await this.deps.writeOwnerMd(ownerAid, task.sub_aid, prepared.raw, latest, task.guard);
         const saved = await this.readOwner(ownerAid, task.sub_aid);
         if (!saved.exists || saved.sha256 !== prepared.sha256 || saved.content !== prepared.raw)
             throw new StateError('ownership published file could not be confirmed');
-        prepared.published_revision = saved.revision;
         await task.persist();
         return prepared;
     }
@@ -513,15 +586,29 @@ export class OwnershipFiles {
             throw new ValidationError('ownership transfer target must differ from current owner');
         return await this.publishOwner(task, 'transfer', 'transfer_owner', task.owner_aid, task.base_relation_version);
     }
+    async requireRecoveredOwner(task) {
+        if (!task.legacy_recovery)
+            return;
+        const pinned = task.files.owner, owner = await this.readOwner(task.owner_aid, task.sub_aid);
+        if (!task.legacy_recovery.owner_confirmed || !pinned || !owner.exists || owner.content !== pinned.raw || owner.sha256 !== pinned.sha256)
+            throw new StateError('ownership recovered owner candidate was replaced', { stringCode: 'conflict', retryable: false });
+        const file = await this.verify(owner.content, 'owner', task.sub_aid, task.owner_aid);
+        if (file.action !== 'declare' || file.statement?.relation_version !== task.target_relation_version)
+            throw new StateError('ownership recovered owner declaration differs', { stringCode: 'conflict', retryable: false });
+    }
     async publishAgent(task, cleanup) {
         const identity = this.local(task.sub_aid), key = cleanup ? 'cleanup' : 'agent';
         const current = await this.readAgent(task.sub_aid);
+        if (!cleanup)
+            await this.requireRecoveredOwner(task);
         let prepared = task.files[key];
         if (!prepared) {
             if (cleanup) {
-                if (current.lock !== 'unlocked' || current.relation_version !== task.target_relation_version)
+                if (current.lock !== 'unlocked' || current.relation_version !== task.base_relation_version)
                     throw new StateError('owner_locked or ownership cleanup version conflict');
                 const prior = current.exists ? parseOwnershipFile(current.content, 'agent', { expectedSubAid: task.sub_aid, now: this.now() }) : null;
+                if (task.expected_agent_statement && (!prior?.statement || !['version', 'declaration_id', 'owner_aid', 'sub_aid', 'relation_version', 'declared_at'].every((field) => prior.statement[field] === task.expected_agent_statement[field])))
+                    throw new StateError('ownership cleanup historical declaration changed', { stringCode: 'conflict', retryable: false });
                 if (prior?.statement && (prior.statement.owner_aid !== task.owner_aid || prior.statement.relation_version !== task.base_relation_version))
                     throw new StateError('ownership cleanup historical authorization mismatch', { stringCode: 'conflict', retryable: false });
             }
@@ -538,7 +625,7 @@ export class OwnershipFiles {
                     throw new StateError('ownership target declaration mismatch', { stringCode: 'conflict', retryable: false });
             }
             const ownerAid = task.operation === 'transfer' ? task.new_owner_aid : task.owner_aid;
-            const payload = buildOwnershipAgentMdV21(current.exists ? current.content : buildDefaultAgentMd(task.sub_aid), cleanup ? undefined : this.statement(ownerAid, task.sub_aid, task.target_relation_version));
+            const payload = buildOwnershipAgentMdV21(current.exists ? current.content : buildDefaultAgentMd(task.sub_aid, { type: this.deps.currentAidType?.() ?? 'agent' }), cleanup ? undefined : this.statement(ownerAid, task.sub_aid, task.target_relation_version));
             const raw = await signOwnershipFile(identity, payload, 'agent', { now: this.now() });
             await this.verify(raw, 'agent', task.sub_aid);
             prepared = { raw, sha256: await ownershipSha256(raw), condition: current.exists ? { if_match: current.etag } : { if_none_match: '*' } };
@@ -546,8 +633,8 @@ export class OwnershipFiles {
             await task.persist();
         }
         if (!prepared.condition || !(typeof prepared.condition.if_match === 'string' && prepared.condition.if_match || prepared.condition.if_none_match === '*'))
-            throw new StateError('ownership original agent.md condition is unavailable', { stringCode: 'ownership_conflict' });
-        if (current.exists && await ownershipSha256(current.content) === prepared.sha256 && current.content === prepared.raw && current.relation_version === task.target_relation_version) {
+            throw new StateError('ownership original resource condition is unavailable', { stringCode: 'ownership_conflict' });
+        if (current.exists && await ownershipSha256(current.content) === prepared.sha256 && current.content === prepared.raw && current.relation_version === (cleanup ? 0 : task.target_relation_version)) {
             if (prepared.published_etag !== undefined && prepared.published_etag !== current.etag)
                 throw new StateError('ownership published agent ETag changed', { stringCode: 'ownership_conflict' });
             prepared.published_etag = current.etag;
@@ -557,7 +644,7 @@ export class OwnershipFiles {
         if (current.exists ? current.etag !== prepared.condition.if_match : prepared.condition.if_none_match !== '*')
             throw new StateError('ownership agent.md condition conflict', { stringCode: 'ownership_conflict' });
         if (cleanup) {
-            if (current.lock !== 'unlocked' || current.relation_version !== task.target_relation_version)
+            if (current.lock !== 'unlocked' || current.relation_version !== task.base_relation_version)
                 throw new StateError('owner_locked or ownership cleanup version conflict');
         }
         else {
@@ -566,10 +653,12 @@ export class OwnershipFiles {
                 await this.verifyTransfer(task);
         }
         await this.verify(prepared.raw, 'agent', task.sub_aid);
+        if (!cleanup)
+            await this.requireRecoveredOwner(task);
         await task.guard?.();
-        const saved = await this.deps.submitAgentMdRaw(task.sub_aid, prepared.raw, prepared.condition);
+        const saved = await this.deps.submitAgentMdRaw(task.sub_aid, prepared.raw, prepared.condition, task.guard);
         this.validateAgentSnapshot(saved, task.sub_aid);
-        if (!saved.exists || await ownershipSha256(saved.content) !== prepared.sha256 || saved.relation_version !== task.target_relation_version)
+        if (!saved.exists || await ownershipSha256(saved.content) !== prepared.sha256 || saved.relation_version !== (cleanup ? 0 : task.target_relation_version))
             throw new StateError('NS ownership submitted file could not be confirmed');
         prepared.published_etag = saved.etag;
         await task.persist();
@@ -581,14 +670,15 @@ export class OwnershipFiles {
         this.local(task.owner_aid);
         await this.readAgent(task.sub_aid);
         const prepared = task.files[task.operation === 'release' ? 'release' : 'transfer'];
-        if (!prepared?.published_revision || prepared.cleaned)
+        if (!prepared || prepared.cleaned)
             return;
+        const began = this.now();
         const consensus = await this.checkConsensus(task.sub_aid);
         if (consensus.status === 'not_applicable')
             throw new StateError(consensus.reason || 'group/org use their dedicated lifecycle ownership', { stringCode: 'not_applicable', retryable: false });
         if (consensus.status === 'invalid' || consensus.status === 'unavailable')
             throw new StateError(consensus.reason || 'ownership cleanup verification failed', { stringCode: consensus.status, retryable: consensus.status === 'unavailable' });
-        if (consensus.relation_version !== task.target_relation_version || (task.operation === 'release' ? consensus.status !== 'released' : consensus.status !== 'consensus' || consensus.owner_aid !== task.new_owner_aid))
+        if (task.operation === 'release' ? !(consensus.status === 'unbound' && consensus.relation_version === 0 || consensus.status === 'consensus') : consensus.relation_version !== task.target_relation_version || consensus.status !== 'consensus' || consensus.owner_aid !== task.new_owner_aid)
             throw new StateError('ownership cleanup relation is not confirmed', { stringCode: 'conflict', retryable: false });
         const object = await this.readOwner(task.owner_aid, task.sub_aid);
         if (!object.exists) {
@@ -596,12 +686,24 @@ export class OwnershipFiles {
             await task.persist();
             return;
         }
-        if (object.revision !== prepared.published_revision || object.sha256 !== prepared.sha256)
-            throw new StateError('ownership cleanup revision conflict');
+        if (object.content !== prepared.raw || object.sha256 !== prepared.sha256)
+            throw new StateError('ownership cleanup original owner file was replaced', { stringCode: 'conflict', retryable: false });
+        const agent = await this.readAgent(task.sub_aid);
+        if (this.now() - began > 30 || agent.etag !== consensus.agent_md_etag || await ownershipSha256(agent.content) !== consensus.agent_md_sha256 || agent.lock !== consensus.lock || agent.relation_version !== consensus.relation_version)
+            throw new StateError('ownership cleanup current files changed', { stringCode: 'unavailable', retryable: true });
         if (!this.deps.deleteOwnerMd)
-            throw new StateError('ownership conditional delete unsupported');
+            throw new StateError('ownership owner file delete unsupported');
+        const latest = await this.readOwner(task.owner_aid, task.sub_aid);
+        if (!latest.exists) {
+            prepared.cleaned = true;
+            await task.persist();
+            return;
+        }
+        if (latest.content !== prepared.raw || latest.sha256 !== prepared.sha256)
+            throw new StateError('ownership cleanup original owner file was replaced', { stringCode: 'conflict', retryable: false });
         await task.guard?.();
-        await this.deps.deleteOwnerMd(task.owner_aid, task.sub_aid, prepared.published_revision);
+        this.fresh(began);
+        await this.deps.deleteOwnerMd(task.owner_aid, task.sub_aid);
         prepared.cleaned = true;
         await task.persist();
     }