@agentunion/fastaun 0.5.19 → 0.5.20

package/dist/ownership-v21.js

@@ -1,7 +1,7 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { updateOwnershipAgentMd } from './agent-md.js';
 import { parseFileFrontmatter, validateAgentMdCertificate, validateAgentMdDocument } from './agent-md-schema.js';
-import { buildAgentMdSignatureBlock, certFingerprint, isStrictBase64, parseAgentMdTailSignature, publicKeyFingerprint, publicKeyMatchesFingerprint, signBytes, verifySignatureWithCert } from './cert-utils.js';
+import { certFingerprint, isStrictBase64, parseAgentMdTailSignature, publicKeyMatchesFingerprint, signDocument, verifyDocument } from './cert-utils.js';
 import { StateError, ValidationError } from './errors.js';
 const AID_RE = /^[a-z0-9_][a-z0-9_-]*(?:\.[a-z0-9_][a-z0-9_-]*)+$/;
 export const OWNERSHIP_UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
@@ -108,7 +108,10 @@ 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 item of parsed.signatures) {
+        const fields = item.fields;
         if (!/^sha256:[0-9a-f]{64}$/.test(fields.cert_fingerprint) || 'public_key_fingerprint' in fields && !/^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)))
@@ -187,8 +190,18 @@ export function verifyOwnershipFile(content, role, certificate, context = {}) {
         throw new ValidationError('ownership certificate fingerprint mismatch');
     if ('public_key_fingerprint' in fields && !publicKeyMatchesFingerprint(certificate.cert_pem, fields.public_key_fingerprint))
         throw new ValidationError('ownership public key fingerprint mismatch');
-    if (!verifySignatureWithCert(certificate.cert_pem, Buffer.from(fields.signature, 'base64'), Buffer.from(parsed.payload, 'utf8')))
-        throw new ValidationError('ownership file signature verification failed');
+    const additional = new Map();
+    for (const item of parseAgentMdTailSignature(new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(parsed.raw)).signatures.slice(1)) {
+        const fields = item.fields, extra = context.certificateResolver?.(fields.signer_aid, fields.cert_fingerprint, Number(fields.timestamp));
+        if (extra && (extra.chain_valid === false || extra.revoked === true || typeof extra.state === 'string' && extra.state !== 'active_signing'))
+            throw new ValidationError('ownership additional signing certificate is not currently verified and active_signing', { stringCode: 'invalid' });
+        if (!extra || extra.chain_valid !== true || extra.revoked !== false || extra.revocation_checked !== true || extra.state !== 'active_signing' || !Number.isSafeInteger(extra.observed_at) || extra.observed_at <= 0 || extra.observed_at > now + 5 || extra.observed_at < now - 30 || !extra.cert_pem?.trim())
+            throw new StateError('ownership additional certificate current status is unavailable', { stringCode: 'unavailable', retryable: true });
+        additional.set(`${fields.signer_aid};${fields.cert_fingerprint}`, extra.cert_pem);
+    }
+    const verified = verifyDocument(new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(parsed.raw), { expectedAid: signer, primaryCertPem: certificate.cert_pem, requireCurrentValidity: true, now, certificateResolver: (aid, fingerprint) => additional.get(`${aid};${fingerprint}`) });
+    if (!verified.valid)
+        throw new ValidationError(verified.reason ?? 'ownership file signature verification failed');
     return parsed;
 }
 export function signOwnershipFile(identity, content, role, context = {}) {
@@ -204,8 +217,7 @@ export 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 = signBytes(identity.privateKeyPem, Buffer.from(parsed.payload, 'utf8')).toString('base64');
-    return parsed.payload + buildAgentMdSignatureBlock(identity.certFingerprint, now, signature, publicKeyFingerprint(identity.certPem), role === 'agent' ? 'AUN-SIGNATURE-AGENTMD-V2' : 'AUN-SIGNATURE-OWNERSHIP-V2');
+    return signDocument(identity, parsed.payload, { timestamp: now, tag: role === 'agent' ? 'AGENTMD-V2' : 'OWNERSHIP-V2' }).signed;
 }
 export function ownershipSha256(content) {
     return createHash('sha256').update(content).digest('hex');
@@ -225,14 +237,13 @@ export class OwnershipFiles {
     async checkConsensus(subAid, target) {
         ownershipAid(subAid, 'sub_aid');
         const began = this.deps.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 before = await this.readAgent(subAid);
             Object.assign(result, { relation_version: before.relation_version, lock: before.lock, agent_md_etag: before.etag, agent_md_sha256: before.exists ? ownershipSha256(before.content) : '' });
-            const released = before.lock === 'unlocked' && before.relation_version > 0;
-            const agent = before.exists && !released ? await this.verifyFile(before.content, 'agent', subAid) : undefined;
+            const agent = before.exists ? await this.verifyFile(before.content, 'agent', subAid) : undefined;
             const statement = agent?.statement;
-            if (before.lock === 'unlocked' && before.relation_version === 0 && statement)
+            if (before.relation_version !== (statement?.relation_version ?? 0))
                 throw ownershipFailure('unavailable', 'NS relation metadata does not match agent.md', true);
             if (before.lock === 'locked' && (!statement || statement.relation_version !== before.relation_version))
                 throw ownershipFailure('unavailable', 'NS locked relation does not match agent.md', true);
@@ -240,29 +251,36 @@ export class OwnershipFiles {
             if (before.owner_aid !== undefined && before.owner_aid !== currentOwner)
                 throw ownershipFailure('unavailable', 'NS owner metadata does not match agent.md', true);
             result.owner_aid = currentOwner;
-            result.status = before.lock === 'unlocked' ? before.relation_version === 0 ? 'unbound' : 'released' : 'single_sided';
-            const ownerAid = released ? undefined : currentOwner ?? target?.owner_aid ?? statement?.owner_aid;
+            result.status = statement ? 'single_sided' : 'unbound';
+            const ownerAid = statement?.owner_aid ?? target?.owner_aid;
+            let ownerBefore;
             if (ownerAid) {
                 const owner = await this.readOwner(ownerAid, subAid);
-                result.owner_md_revision = owner.revision;
-                result.owner_md_sha256 = owner.sha256 ?? '';
+                ownerBefore = owner;
+                result.owner_md_sha256 = owner.exists ? owner.sha256 ?? '' : '';
                 if (owner.exists) {
                     const declaration = await this.verifyFile(owner.content, 'owner', subAid, ownerAid);
-                    if (before.lock === 'locked') {
+                    if (statement) {
                         if (declaration.statement.relation_version !== before.relation_version)
                             throw new ValidationError('ownership relation_version mismatch');
-                        if (declaration.action === 'release')
-                            throw ownershipFailure('unavailable', 'NS has not confirmed the current release', true);
-                        result.status = 'consensus';
+                        result.status = declaration.action === 'release' ? 'released' : 'consensus';
                     }
                     else if (target && declaration.action === 'declare' && declaration.statement.relation_version === target.relation_version && target.relation_version === before.relation_version + 1) {
                         result.status = 'single_sided';
                     }
                 }
-                else if (before.lock === 'locked')
-                    throw ownershipFailure('unavailable', 'NS has not confirmed owner object absence', true);
+                else if (statement)
+                    result.status = 'released';
             }
+            if (statement && before.lock !== (result.status === 'released' ? 'unlocked' : 'locked'))
+                throw ownershipFailure('unavailable', 'NS lock does not match current ownership materials', true);
+            result.owner_aid = result.status === 'consensus' ? statement.owner_aid : null;
             const after = await this.readAgent(subAid);
+            if (ownerAid && ownerBefore) {
+                const ownerAfter = await this.readOwner(ownerAid, subAid);
+                if (ownerBefore.exists !== ownerAfter.exists || ownerBefore.content !== ownerAfter.content || ownerBefore.sha256 !== ownerAfter.sha256)
+                    throw ownershipFailure('unavailable', 'owner.md changed during consensus check', true);
+            }
             if (before.exists !== after.exists || before.etag !== after.etag || before.relation_version !== after.relation_version || before.lock !== after.lock || before.content !== after.content || before.owner_aid !== after.owner_aid || this.deps.now() - began > 30)
                 throw ownershipFailure('unavailable', 'NS relation changed or verification window elapsed during consensus check', true);
             return result;
@@ -316,11 +334,15 @@ export class OwnershipFiles {
         return this.publishAgent(task, async (agent) => {
             if (agent.lock === 'locked')
                 throw ownershipFailure('owner_locked', 'NS has not confirmed release');
+            const parsed = parseOwnershipFile(agent.content, 'agent', { expectedSubAid: task.sub_aid });
+            if (!parsed.statement && agent.relation_version === 0)
+                return {};
             if (agent.relation_version !== task.target_relation_version)
                 throw ownershipFailure('conflict', 'release relation_version changed');
-            const parsed = parseOwnershipFile(agent.content, 'agent', { expectedSubAid: task.sub_aid });
             if (parsed.statement && (parsed.statement.owner_aid !== task.owner_aid || parsed.statement.relation_version !== task.base_relation_version))
                 throw ownershipFailure('conflict', 'agent.md no longer contains the released relation');
+            if (task.expected_agent_statement && Object.keys(task.expected_agent_statement).some((field) => task.expected_agent_statement[field] !== parsed.statement?.[field]))
+                throw ownershipFailure('conflict', 'agent.md no longer contains the approved statement');
             return {};
         }, true);
     }
@@ -338,8 +360,8 @@ export class OwnershipFiles {
     async cleanupOwnerFile(task) {
         this.requireLocal(task.owner_aid);
         const source = this.savedFile(task, task.operation === 'release' ? 'release' : 'transfer');
-        if (!source?.published_revision)
-            throw ownershipFailure('conflict', 'original published owner revision is unavailable');
+        if (!source)
+            throw ownershipFailure('conflict', 'original owner file is unavailable');
         const consensus = await this.checkConsensus(task.sub_aid);
         if (consensus.status === 'not_applicable')
             throw ownershipFailure('not_applicable', consensus.reason ?? 'group/org use their dedicated lifecycle ownership');
@@ -347,19 +369,24 @@ export class OwnershipFiles {
             throw new ValidationError(consensus.reason ?? 'ownership consensus is invalid', { stringCode: 'invalid' });
         if (consensus.status === 'unavailable')
             throw ownershipFailure(consensus.code ?? 'unavailable', consensus.reason ?? 'ownership consensus is unavailable', true);
-        if (consensus.relation_version !== task.target_relation_version || task.operation === 'release' && consensus.status !== 'released' || task.operation === 'transfer' && (consensus.status !== 'consensus' || consensus.owner_aid !== task.new_owner_aid))
-            throw ownershipFailure('conflict', 'NS has not confirmed this task target');
+        if (task.operation === 'release' && consensus.status === 'released')
+            return;
+        if (task.operation === 'release' ? consensus.status !== 'unbound' && consensus.status !== 'consensus' : consensus.relation_version !== task.target_relation_version || consensus.status !== 'consensus' || consensus.owner_aid !== task.new_owner_aid)
+            throw ownershipFailure('conflict', 'current materials do not permit this task cleanup');
         const current = await this.readOwner(task.owner_aid, task.sub_aid);
-        if (current.exists && (current.revision !== source.published_revision || current.sha256 !== source.hash))
-            throw ownershipFailure('conflict', 'owner file revision changed before cleanup');
+        if (current.exists && (current.content !== source.raw || current.sha256 !== source.hash))
+            throw ownershipFailure('conflict', 'owner file changed before cleanup');
         if (!task.files.cleanup) {
-            task.files.cleanup = { raw: source.raw, hash: source.hash, condition: { expected_revision: source.published_revision } };
+            task.files.cleanup = { raw: source.raw, hash: source.hash, condition: {} };
             await task.persist();
         }
         else
             this.savedFile(task, 'cleanup');
-        if (current.exists)
-            await this.deps.deleteOwnerMd(task.owner_aid, task.sub_aid, source.published_revision);
+        const beforeDelete = await this.readOwner(task.owner_aid, task.sub_aid);
+        if (beforeDelete.exists && (beforeDelete.content !== source.raw || beforeDelete.sha256 !== source.hash))
+            throw ownershipFailure('conflict', 'owner file changed before cleanup');
+        if (beforeDelete.exists)
+            await this.deps.deleteOwnerMd(task.owner_aid, task.sub_aid);
         task.files.cleanup.deleted = true;
         await task.persist();
     }
@@ -379,7 +406,7 @@ export class OwnershipFiles {
     async readOwner(ownerAid, subAid) {
         const value = await this.deps.readOwnerMd(ownerAid, subAid);
         const now = this.deps.now();
-        if (value.owner_aid !== ownerAid || value.sub_aid !== undefined && value.sub_aid !== subAid || value.bucket !== 'default' || value.path !== `sub_aids/${subAid}/owner.md` || typeof value.exists !== 'boolean' || typeof value.revision !== 'string' || !value.revision || !Number.isSafeInteger(value.observed_at) || value.observed_at > now + 5 || value.observed_at < now - 30 || value.authoritative !== true || value.recovery_ready !== undefined && value.recovery_ready !== true || value.service_aid !== `st.${ownerAid.slice(ownerAid.indexOf('.') + 1)}` || value.service_aid !== value.authenticated_service_aid || typeof value.content !== 'string' || value.exists && !/^[0-9a-f]{64}$/.test(value.sha256 ?? ''))
+        if (value.owner_aid !== ownerAid || value.sub_aid !== undefined && value.sub_aid !== subAid || value.bucket !== 'default' || value.path !== `sub_aids/${subAid}/owner.md` || typeof value.exists !== 'boolean' || !Number.isSafeInteger(value.observed_at) || value.observed_at > now + 5 || value.observed_at < now - 30 || value.authoritative !== true || value.recovery_ready !== undefined && value.recovery_ready !== true || value.service_aid !== `st.${ownerAid.slice(ownerAid.indexOf('.') + 1)}` || value.service_aid !== value.authenticated_service_aid || typeof value.content !== 'string' || value.exists && !/^[0-9a-f]{64}$/.test(value.sha256 ?? ''))
             throw ownershipFailure('unavailable', 'Storage authoritative observation is incomplete or changed', true);
         if (value.exists && value.sha256 !== ownershipSha256(value.content))
             throw ownershipFailure('unavailable', 'Storage complete file digest does not match authoritative observation', true);
@@ -396,13 +423,19 @@ export class OwnershipFiles {
         const parsed = parseOwnershipFile(raw, role, context);
         const signer = role === 'agent' ? subAid : String(parsed.frontmatter.owner_aid);
         const certificate = await this.deps.resolveCertificate(signer, parsed.signature.cert_fingerprint, role === 'agent' && parsed.frontmatter.type === 'group' ? 'group_identity' : undefined);
-        return verifyOwnershipFile(raw, role, certificate, { ...context, now: this.deps.now() });
+        const additional = new Map();
+        for (const item of parseAgentMdTailSignature(raw).signatures.slice(1))
+            additional.set(`${item.fields.signer_aid};${item.fields.cert_fingerprint}`, await this.deps.resolveCertificate(item.fields.signer_aid, item.fields.cert_fingerprint));
+        return verifyOwnershipFile(raw, role, certificate, { ...context, now: this.deps.now(), certificateResolver: (aid, fingerprint) => additional.get(`${aid};${fingerprint}`) });
     }
     async requireTransfer(task) {
         const owner = await this.readOwner(task.owner_aid, task.sub_aid);
         if (!owner.exists)
             throw ownershipFailure('unavailable', 'original owner authorization is missing', true);
         const authorization = await this.verifyFile(owner.content, 'owner', task.sub_aid, task.owner_aid);
+        const saved = task.files.transfer;
+        if (saved && (saved.raw !== owner.content || saved.hash !== owner.sha256))
+            throw ownershipFailure('conflict', 'fixed transfer authorization changed');
         if (authorization.action !== 'transfer_owner' || authorization.statement.relation_version !== task.base_relation_version || authorization.transfer.new_owner_aid !== task.new_owner_aid || authorization.transfer.target_relation_version !== task.target_relation_version)
             throw ownershipFailure('conflict', 'transfer authorization does not match this task');
         const expiresAt = authorization.transfer.expires_at;
@@ -429,17 +462,22 @@ export class OwnershipFiles {
     }
     async assertBase(task, agent) {
         ownershipInteger(task.base_relation_version, 'base_relation_version', 0);
-        if (ownershipInteger(task.target_relation_version, 'target_relation_version') !== task.base_relation_version + 1 || agent.relation_version !== task.base_relation_version)
+        if (ownershipInteger(task.target_relation_version, 'target_relation_version') !== task.base_relation_version + (task.operation === 'release' ? 0 : 1) || agent.relation_version !== task.base_relation_version)
             throw ownershipFailure('conflict', 'NS relation_version changed');
         if (!agent.exists)
             throw ownershipFailure('unavailable', 'initial agent.md is not published', true);
-        const parsed = agent.lock === 'unlocked' && agent.relation_version > 0 ? parseOwnershipFile(agent.content, 'agent', { expectedSubAid: task.sub_aid }) : await this.verifyFile(agent.content, 'agent', task.sub_aid);
-        if (agent.lock === 'unlocked' && agent.relation_version === 0 && parsed.statement)
+        const parsed = await this.verifyFile(agent.content, 'agent', task.sub_aid);
+        const base = task.base_agent_md;
+        if (base && (agent.exists !== base.exists || (base.statement ? !parsed.statement || Object.keys(base.statement).some((field) => base.statement[field] !== parsed.statement[field]) : parsed.statement || agent.content !== base.raw || ownershipSha256(agent.content) !== base.sha256)))
+            throw ownershipFailure('conflict', 'the original ownership statement was replaced');
+        if (agent.relation_version !== (parsed.statement?.relation_version ?? 0))
             throw ownershipFailure('unavailable', 'NS relation metadata does not match agent.md', true);
         if (task.operation === 'bind' && parsed.frontmatter.type === 'human')
             throw ownershipFailure('invalid', 'human cannot declare an owner');
         if (task.operation === 'bind' && agent.lock !== 'unlocked')
             throw ownershipFailure('owner_locked', 'an existing owner relation is locked');
+        if (task.operation === 'bind' && parsed.statement?.owner_aid === this.targetOwner(task))
+            throw ownershipFailure('conflict', 'clear the released agent.md statement before binding the same owner');
         if (task.operation !== 'bind' && (agent.lock !== 'locked' || parsed.statement?.owner_aid !== task.owner_aid || parsed.statement.relation_version !== task.base_relation_version))
             throw ownershipFailure('conflict', 'the original relation is no longer current');
     }
@@ -451,25 +489,35 @@ export class OwnershipFiles {
     }
     savedFile(task, key) {
         const saved = task.files[key];
-        if (saved && (typeof saved.raw !== 'string' || saved.hash !== ownershipSha256(saved.raw) || !this.validSavedCondition(key, saved.condition) || saved.published_revision !== undefined && (typeof saved.published_revision !== 'string' || !saved.published_revision)))
+        if (saved && (typeof saved.raw !== 'string' || saved.hash !== ownershipSha256(saved.raw) || !this.validSavedCondition(key, saved.condition) || saved.published_etag !== undefined && (typeof saved.published_etag !== 'string' || !saved.published_etag)))
             throw ownershipFailure('persistence_unavailable', 'saved ownership file is corrupt');
+        const original = saved?.original_owner;
+        if (saved && key !== 'agent' && key !== 'cleanup' && (!original || typeof original.exists !== 'boolean' || typeof original.raw !== 'string' || original.sha256 !== (original.exists ? ownershipSha256(original.raw) : '') || !original.exists && original.raw !== ''))
+            throw ownershipFailure('persistence_unavailable', 'original owner.md evidence is corrupt');
         return saved;
     }
     validSavedCondition(key, condition) {
-        if (!condition || typeof condition !== 'object' || Object.keys(condition).length !== 1)
+        if (!condition || typeof condition !== 'object')
+            return false;
+        if (key !== 'agent')
+            return Object.keys(condition).length === 0;
+        if (Object.keys(condition).length !== 1)
             return false;
         if (key === 'agent')
             return typeof condition.if_match === 'string' && condition.if_match.length > 0 || condition.if_none_match === '*';
-        return typeof condition.expected_revision === 'string' && condition.expected_revision.length > 0;
+        return false;
     }
     async publishOwner(task, key, ownerAid, prepare) {
         let saved = this.savedFile(task, key);
         await this.readAgent(task.sub_aid);
         const current = await this.readOwner(ownerAid, task.sub_aid);
         if (!saved) {
+            const base = task.base_owner_md;
+            if (base && ownerAid === task.base_agent_md?.statement?.owner_aid && (current.exists !== base.exists || current.content !== base.raw || (current.exists ? current.sha256 : '') !== base.sha256))
+                throw ownershipFailure('conflict', 'original owner.md material changed before publication');
             const ownership = await prepare(current);
             const raw = signOwnershipFile(this.deps.currentAid(), `---\nowner_aid: ${ownerAid}\nsub_aid: ${task.sub_aid}\nownership: ${JSON.stringify(ownership)}\n---\n`, 'owner', { now: this.deps.now(), expectedOwnerAid: ownerAid, expectedSubAid: task.sub_aid });
-            saved = { raw, hash: ownershipSha256(raw), condition: { expected_revision: current.revision } };
+            saved = { raw, hash: ownershipSha256(raw), condition: {}, original_owner: { exists: current.exists, raw: current.content, sha256: current.exists ? ownershipSha256(current.content) : '' } };
             if (key === 'transfer')
                 saved.expires_at = ownership.transfer.expires_at;
             task.files[key] = saved;
@@ -477,23 +525,25 @@ export class OwnershipFiles {
         }
         await this.verifyFile(saved.raw, 'owner', task.sub_aid, ownerAid);
         if (current.exists && current.sha256 === saved.hash && current.content === saved.raw) {
-            if (saved.published_revision !== undefined && current.revision !== saved.published_revision)
-                throw ownershipFailure('conflict', 'owner file published revision changed');
-            saved.published_revision = current.revision;
             await task.persist();
             return current;
         }
-        if (current.revision !== saved.condition.expected_revision)
-            throw ownershipFailure('conflict', 'owner file original revision changed');
+        const original = saved.original_owner;
+        if (!original || typeof original.exists !== 'boolean' || typeof original.raw !== 'string' || original.sha256 !== (original.exists ? ownershipSha256(original.raw) : ''))
+            throw ownershipFailure('persistence_unavailable', 'owner file original material is missing or corrupt');
+        if (current.exists !== original.exists || current.content !== original.raw || (current.exists ? current.sha256 : '') !== original.sha256)
+            throw ownershipFailure('conflict', 'owner file original material changed');
         await this.assertBase(task, await this.readAgent(task.sub_aid));
         if (key === 'owner' && task.operation === 'transfer')
             await this.requireTransfer(task);
         if (key === 'transfer' && saved.expires_at <= this.deps.now())
             throw ownershipFailure('conflict', 'transfer authorization expired');
-        const published = await this.deps.writeOwnerMd(ownerAid, task.sub_aid, saved.raw, saved.condition.expected_revision);
-        if (!published.exists || !published.revision || published.sha256 !== saved.hash || published.content !== saved.raw)
+        const beforeWrite = await this.readOwner(ownerAid, task.sub_aid);
+        if (beforeWrite.exists !== original.exists || beforeWrite.content !== original.raw || (beforeWrite.exists ? beforeWrite.sha256 : '') !== original.sha256)
+            throw ownershipFailure('conflict', 'owner file original material changed before publication');
+        const published = await this.deps.writeOwnerMd(ownerAid, task.sub_aid, saved.raw);
+        if (!published.exists || published.sha256 !== saved.hash || published.content !== saved.raw)
             throw ownershipFailure('unavailable', 'owner publication could not be verified', true);
-        saved.published_revision = published.revision;
         await task.persist();
         return published;
     }
@@ -511,10 +561,10 @@ export class OwnershipFiles {
             await task.persist();
         }
         await this.verifyFile(saved.raw, 'agent', task.sub_aid);
-        if (current.exists && ownershipSha256(current.content) === saved.hash && current.content === saved.raw && current.relation_version === task.target_relation_version && current.lock === (cleanup ? 'unlocked' : 'locked')) {
-            if (saved.published_revision !== undefined && current.etag !== saved.published_revision)
+        if (current.exists && ownershipSha256(current.content) === saved.hash && current.content === saved.raw && current.relation_version === (cleanup ? 0 : task.target_relation_version) && current.lock === (cleanup ? 'unlocked' : 'locked')) {
+            if (saved.published_etag !== undefined && current.etag !== saved.published_etag)
                 throw ownershipFailure('conflict', 'agent.md published ETag changed');
-            saved.published_revision = current.etag;
+            saved.published_etag = current.etag;
             await task.persist();
             return current;
         }
@@ -532,13 +582,16 @@ export class OwnershipFiles {
             if (!target.exists)
                 throw ownershipFailure('unavailable', 'target owner declaration is missing', true);
             const declaration = await this.verifyFile(target.content, 'owner', task.sub_aid, this.targetOwner(task));
+            const savedOwner = task.files.owner;
+            if (savedOwner && (savedOwner.raw !== target.content || savedOwner.hash !== target.sha256))
+                throw ownershipFailure('conflict', 'fixed target owner declaration changed');
             if (declaration.action !== 'declare' || declaration.statement.relation_version !== task.target_relation_version)
                 throw ownershipFailure('conflict', 'target owner declaration changed');
         }
         const published = await this.deps.submitAgentMdRaw(task.sub_aid, saved.raw, saved.condition);
-        if (published.content !== saved.raw || published.relation_version !== task.target_relation_version || published.lock !== (cleanup ? 'unlocked' : 'locked'))
+        if (published.content !== saved.raw || published.relation_version !== (cleanup ? 0 : task.target_relation_version) || published.lock !== (cleanup ? 'unlocked' : 'locked'))
             throw ownershipFailure('unavailable', 'agent.md publication could not be verified', true);
-        saved.published_revision = published.etag;
+        saved.published_etag = published.etag;
         await task.persist();
         return published;
     }
@@ -557,21 +610,24 @@ export class OwnershipStorageAdapter {
             return result;
         }
         catch (error) {
+            const reading = method === 'storage.head_object' || method === 'storage.get_object';
             const code = error && typeof error === 'object' ? error.code : undefined;
             if (error instanceof ValidationError && code !== -32601 || error instanceof StateError && error.stringCode === 'invalid')
                 throw new ValidationError(error.message, { stringCode: 'invalid' });
             if (error instanceof StateError && ['unavailable', 'unsupported_protocol', 'conflict'].includes(error.stringCode))
                 throw ownershipFailure(error.stringCode, error.message, error.stringCode !== 'conflict');
+            if (reading && error instanceof StateError && error.stringCode === 'forbidden')
+                throw ownershipFailure('unavailable', error.message, true);
             if (error instanceof StateError && error.stringCode)
                 throw error;
-            throw ownershipFailure(code === -32009 ? 'conflict' : code === -32004 ? 'forbidden' : code === -32601 ? 'unsupported_protocol' : 'unavailable', error instanceof Error ? error.message : String(error), ![-32009, -32004].includes(code ?? 0));
+            throw ownershipFailure(code === -32009 ? 'conflict' : code === -32004 ? reading ? 'unavailable' : 'forbidden' : code === -32601 ? 'unsupported_protocol' : 'unavailable', error instanceof Error ? error.message : String(error), code !== -32009 && (reading || code !== -32004));
         }
     }
     metadata(value, ownerAid, path) {
         const now = this.now();
         const expectedService = `st.${ownerAid.slice(ownerAid.indexOf('.') + 1)}`;
-        if (value.consistency !== 'authoritative' || value.owner_aid !== ownerAid || value.bucket !== 'default' || value.path !== path || typeof value.exists !== 'boolean' || typeof value.revision !== 'string' || !value.revision || !Number.isSafeInteger(value.observed_at) || Number(value.observed_at) < now - 30 || Number(value.observed_at) > now + 5 || value.recovery_ready !== undefined && value.recovery_ready !== true || value.service_aid !== undefined && value.service_aid !== expectedService || value.authenticated_service_aid !== undefined && value.authenticated_service_aid !== expectedService || 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) < 1))
-            throw ownershipFailure('unavailable', 'Storage authoritative namespace, revision or freshness metadata is incomplete', true);
+        if (value.consistency !== 'authoritative' || value.owner_aid !== ownerAid || value.bucket !== 'default' || value.path !== path || typeof value.exists !== 'boolean' || !Number.isSafeInteger(value.observed_at) || Number(value.observed_at) < now - 30 || Number(value.observed_at) > now + 5 || value.recovery_ready !== undefined && value.recovery_ready !== true || value.service_aid !== undefined && value.service_aid !== expectedService || value.authenticated_service_aid !== undefined && value.authenticated_service_aid !== expectedService || value.exists && (typeof value.sha256 !== 'string' || !/^[0-9a-f]{64}$/.test(value.sha256)))
+            throw ownershipFailure('unavailable', 'Storage authoritative namespace or freshness metadata is incomplete', true);
     }
     async readObject(ownerAid, path) {
         ownershipAid(ownerAid, 'owner_aid');
@@ -582,9 +638,9 @@ export class OwnershipStorageAdapter {
         let content = '';
         let final = before;
         if (before.exists) {
-            const object = await this.call('storage.get_object', { ...params, expected_revision: before.revision });
+            const object = await this.call('storage.get_object', params);
             this.metadata(object, ownerAid, path);
-            if (object.exists !== true || object.revision !== before.revision || object.sha256 !== before.sha256 || object.object_id !== before.object_id || object.version !== before.version || typeof object.content !== 'string')
+            if (object.exists !== true || object.sha256 !== before.sha256 || typeof object.content !== 'string')
                 throw ownershipFailure('unavailable', 'Storage object changed or full Base64 content is unavailable', true);
             if (object.content !== '' && !isStrictBase64(object.content))
                 throw ownershipFailure('unavailable', 'Storage Base64 content is unavailable', true);
@@ -599,33 +655,54 @@ export class OwnershipStorageAdapter {
             }
             final = await this.call('storage.head_object', params);
             this.metadata(final, ownerAid, path);
-            if (final.exists !== true || final.revision !== before.revision || final.sha256 !== before.sha256 || final.object_id !== before.object_id || final.version !== before.version || this.now() - began > 30)
-                throw ownershipFailure('unavailable', 'Storage revision changed during authoritative read', true);
+            if (final.exists !== true || final.sha256 !== before.sha256 || this.now() - began > 30)
+                throw ownershipFailure('unavailable', 'Storage material changed during authoritative read', true);
         }
         const service = `st.${ownerAid.slice(ownerAid.indexOf('.') + 1)}`;
-        return { owner_aid: ownerAid, bucket: 'default', path, exists: Boolean(final.exists), revision: String(final.revision), observed_at: Number(final.observed_at),
-            content, sha256: final.exists ? String(final.sha256) : undefined, authoritative: true, recovery_ready: final.recovery_ready, service_aid: service, authenticated_service_aid: service };
+        return { owner_aid: ownerAid, bucket: 'default', path, exists: Boolean(final.exists), observed_at: Number(final.observed_at),
+            content, sha256: final.exists ? String(final.sha256) : undefined, authoritative: true, recovery_ready: final.recovery_ready, service_aid: service, authenticated_service_aid: service, version: final.exists && Number.isSafeInteger(final.version) && Number(final.version) > 0 ? final.version : undefined };
     }
     async readOwnerMd(ownerAid, subAid) {
         ownershipAid(subAid, 'sub_aid');
         return this.readObject(ownerAid, `sub_aids/${subAid}/owner.md`);
     }
-    async writeOwnerMd(ownerAid, subAid, raw, originalRevision) {
+    async writeOwnerMd(ownerAid, subAid, raw) {
         this.requireLocal(ownerAid);
         ownershipAid(subAid, 'sub_aid');
-        if (typeof originalRevision !== 'string' || !originalRevision)
-            throw ownershipFailure('invalid', 'original Storage revision is required');
-        await this.call('storage.put_object', { owner_aid: ownerAid, bucket: 'default', object_key: `sub_aids/${subAid}/owner.md`, content: Buffer.from(raw, 'utf8').toString('base64'), content_type: 'text/markdown; charset=utf-8', is_private: false, overwrite: true, expected_revision: originalRevision });
+        const path = `sub_aids/${subAid}/owner.md`;
+        const before = await this.readOwnerMd(ownerAid, subAid);
+        const bytes = new TextEncoder().encode(raw);
+        const expectedVersion = before.exists ? before.version : 0;
+        if (typeof expectedVersion !== 'number' || !Number.isSafeInteger(expectedVersion) || expectedVersion < (before.exists ? 1 : 0))
+            throw ownershipFailure('unavailable', 'Storage owner.md version is unavailable', true);
+        const session = await this.call('storage.create_upload_session', { owner_aid: ownerAid, 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 ownershipFailure('unavailable', 'Storage owner.md upload session is incomplete', true);
+        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';
+        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 ownershipFailure('unavailable', `Storage owner.md HTTP PUT failed: ${response.status}`, true);
+        }
+        const complete = { owner_aid: ownerAid, bucket: 'default', object_key: path, session_id: sessionID, size_bytes: bytes.length, sha256: ownershipSha256(bytes), content_type: 'text/markdown; charset=utf-8', is_private: false, overwrite: true };
+        complete.expected_version = expectedVersion;
+        await this.call('storage.complete_upload', complete);
         return this.readOwnerMd(ownerAid, subAid);
     }
-    async deleteOwnerMd(ownerAid, subAid, originalRevision) {
+    async deleteOwnerMd(ownerAid, subAid) {
         this.requireLocal(ownerAid);
         ownershipAid(subAid, 'sub_aid');
-        if (typeof originalRevision !== 'string' || !originalRevision)
-            throw ownershipFailure('invalid', 'original Storage revision is required');
-        await this.call('storage.delete_object', { owner_aid: ownerAid, bucket: 'default', object_key: `sub_aids/${subAid}/owner.md`, expected_revision: originalRevision });
+        await this.call('storage.delete_object', { owner_aid: ownerAid, bucket: 'default', object_key: `sub_aids/${subAid}/owner.md` });
         if ((await this.readOwnerMd(ownerAid, subAid)).exists)
-            throw ownershipFailure('unavailable', 'Storage conditional deletion could not be confirmed', true);
+            throw ownershipFailure('unavailable', 'Storage deletion could not be confirmed', true);
     }
     requireLocal(ownerAid) {
         if (ownershipAid(ownerAid, 'owner_aid') !== this.deps.currentAid())