@agentunion/fastaun 0.5.21 → 0.5.23

package/dist/ownership-workflow.js

@@ -114,7 +114,7 @@ export function parseOwnershipMessage(content, context) {
         const ns = context.ns;
         if (ns.protocol !== '2.1')
             throw ownershipFailure('unsupported_protocol', 'NS ownership protocol is unavailable');
-        const base = ns.relation_version === message.base_relation_version && (message.operation === 'bind' ? ns.lock === 'unlocked' && !ns.owner_aid : ns.lock === 'locked' && ns.owner_aid === message.owner_aid);
+        const base = ns.relation_version === message.base_relation_version && (message.operation === 'bind' ? ns.lock === 'unlocked' && !ns.owner_aid : ns.lock === 'locked' && ns.owner_aid === message.owner_aid) || message.operation === 'bind' && ns.relation_version === message.target_relation_version && ns.lock === 'unlocked' && (ns.pending || ns.ownership_status === 'pending');
         const target = message.operation === 'release' ? ns.lock === 'unlocked' && !ns.owner_aid && (ns.relation_version === message.base_relation_version || ns.relation_version === 0) : ns.relation_version === message.target_relation_version && ns.lock === 'locked' && ns.owner_aid === targetOwner(message);
         if (['relation.confirmed', 'sub.cleaned'].includes(message.action) ? !target : !base && !target)
             throw ownershipFailure('conflict', 'ownership current NS relation does not match this task');
@@ -560,17 +560,38 @@ export class OwnershipWorkflow {
                 if (!base || typeof base.exists !== 'boolean' || typeof base.raw !== 'string' || base.sha256 !== ownershipSha256(base.raw) || typeof base.etag !== 'string' || (base.exists ? !base.etag : base.raw !== '' || base.etag !== '' || record.operation !== 'bind' || record.base_relation_version !== 0))
                     throw new Error('ownership original agent.md evidence is corrupt');
                 const statement = base.exists ? parseOwnershipFile(base.raw, 'agent', { expectedSubAid: record.sub_aid }).statement ?? null : null;
-                if (JSON.stringify(statement) !== JSON.stringify(base.statement) || (statement?.relation_version ?? 0) !== record.base_relation_version)
+                if (JSON.stringify(statement) !== JSON.stringify(base.statement) || (statement?.relation_version ?? 0) !== record.base_relation_version && !(base.pending && statement?.relation_version === record.target_relation_version && statement.owner_aid === record.owner_aid) || base.pending && record.operation !== 'bind')
                     throw new Error('ownership original statement is corrupt');
                 const owner = record.base_owner_md;
                 if (!owner || typeof owner.exists !== 'boolean' || typeof owner.raw !== 'string' || owner.sha256 !== (owner.exists ? ownershipSha256(owner.raw) : '') || !owner.exists && owner.raw !== '')
                     throw new Error('ownership original owner.md evidence is corrupt');
                 if (owner.exists) {
                     const declaration = parseOwnershipFile(owner.raw, 'owner', { expectedSubAid: record.sub_aid, expectedOwnerAid: statement?.owner_aid ?? record.owner_aid });
-                    if (declaration.statement?.relation_version !== record.base_relation_version)
+                    if (!base.pending && declaration.statement?.relation_version !== record.base_relation_version)
                         throw new Error('ownership original owner statement is corrupt');
                 }
             }
+            if (record.pending_agent_md) {
+                const pending = record.pending_agent_md;
+                const statement = parseOwnershipFile(pending.raw, 'agent', { expectedSubAid: record.sub_aid }).statement;
+                if (record.operation !== 'bind' || pending.sha256 !== ownershipSha256(pending.raw) || !pending.etag || statement?.owner_aid !== record.owner_aid || statement.relation_version !== record.target_relation_version)
+                    throw new Error('ownership pending original is corrupt');
+            }
+            if (record.owner_proposal) {
+                const proposal = record.owner_proposal, file = parseOwnershipFile(proposal.raw, 'owner', { expectedSubAid: record.sub_aid, expectedOwnerAid: record.owner_aid });
+                if (!this.ownerFirst(record) || proposal.sha256 !== ownershipSha256(proposal.raw) || file.action !== 'declare' || file.statement?.relation_version !== record.target_relation_version)
+                    throw new Error('ownership owner proposal is corrupt');
+            }
+            if (record.owner_first !== undefined && (record.owner_first !== true || record.operation !== 'bind' || record.initiator_aid !== record.owner_aid || record.sub_aid === record.owner_aid) || record.owner_first && record.request_verified && this.local() === record.sub_aid && !record.owner_proposal)
+                throw new Error('ownership owner-first context is corrupt');
+            if (record.rejection_cleanup) {
+                const cleanup = record.rejection_cleanup;
+                if (record.operation !== 'bind' || record.status !== 'rejected' || !record.local_roles.includes('sub') || !record.files.agent || typeof cleanup.cleaned !== 'boolean' || !cleanup.files || Object.keys(cleanup.files).some((key) => key !== 'agent'))
+                    throw new Error('ownership rejection cleanup is corrupt');
+                const file = cleanup.files.agent;
+                if (file && (file.hash !== ownershipSha256(file.raw) || file.condition.if_match !== record.files.agent.published_etag || Object.keys(file.condition).length !== 1 || parseOwnershipFile(file.raw, 'agent', { expectedSubAid: record.sub_aid }).statement))
+                    throw new Error('ownership rejection cleanup original is corrupt');
+            }
             for (const item of record.inbox)
                 parseOwnershipMessage(item.payload, { authenticated_from_aid: item.from, local_aid: this.local(), task: record });
             for (const key of record.received) {
@@ -778,7 +799,8 @@ export class OwnershipWorkflow {
         const base = ns.relation_version === record.base_relation_version && (record.operation === 'bind' ? ns.lock === 'unlocked' && !ns.owner_aid : ns.lock === 'locked' && ns.owner_aid === record.owner_aid);
         const released = record.operation === 'release' && ns.lock === 'unlocked' && !ns.owner_aid && ns.relation_version === record.base_relation_version;
         const committed = record.operation !== 'release' && ns.lock === 'locked' && ns.owner_aid === targetOwner(record) && ns.relation_version === record.target_relation_version;
-        if (!base && !released && !committed)
+        const pending = record.operation === 'bind' && ns.lock === 'unlocked' && (ns.pending || ns.ownership_status === 'pending') && ns.relation_version === record.target_relation_version && parseOwnershipFile(ns.content, 'agent', { expectedSubAid: record.sub_aid }).statement?.owner_aid === record.owner_aid;
+        if (!base && !released && !committed && !pending)
             throw ownershipFailure('conflict', 'legacy relationship no longer matches this task');
         if (!committed)
             await this.captureBase(record, ns);
@@ -879,6 +901,8 @@ export class OwnershipWorkflow {
         };
         if (context.operation === 'transfer')
             record.new_owner_aid = context.new_owner_aid;
+        if (context.operation === 'bind' && initiator === context.owner_aid && context.owner_aid !== context.sub_aid)
+            record.owner_first = true;
         record.approvals[this.local()] = decision;
         return record;
     }
@@ -927,7 +951,7 @@ export class OwnershipWorkflow {
                     await this.recordError(active, error);
                     return ownershipTaskResult(record);
                 }
-                let base = ns.relation_version === record.base_relation_version && (record.operation === 'bind' ? ns.lock === 'unlocked' && !ns.owner_aid : ns.lock === 'locked' && ns.owner_aid === record.owner_aid);
+                let base = this.isBase(record, ns);
                 if (base && record.request_verified) {
                     try {
                         await this.assertBaseMaterial(active, ns);
@@ -958,11 +982,13 @@ export class OwnershipWorkflow {
             ns = await this.readNs(subAid);
             if (operation === 'bind' && ns.lock !== 'unlocked')
                 throw ownershipFailure('owner_locked', 'the current owner relation is locked');
+            if (operation === 'bind' && subAid !== this.local() && (ns.pending || ns.ownership_status === 'pending'))
+                throw ownershipFailure('conflict', 'pending ownership must resume its original operation');
             if (!ns.exists && operation !== 'bind')
                 throw ownershipFailure('conflict', 'original agent.md is missing');
             if (operation === 'bind' && (ns.exists ? parseOwnershipFile(ns.content, 'agent', { expectedSubAid: subAid }).frontmatter.type : subAid === this.local() ? this.deps.currentType?.() : undefined) === 'human')
                 throw ownershipFailure('invalid', 'human cannot declare an owner');
-            if (operation === 'bind' && ns.exists && parseOwnershipFile(ns.content, 'agent', { expectedSubAid: subAid }).statement?.owner_aid === ownerAid)
+            if (operation === 'bind' && ns.exists && !(ns.pending || ns.ownership_status === 'pending') && parseOwnershipFile(ns.content, 'agent', { expectedSubAid: subAid }).statement?.owner_aid === ownerAid)
                 throw ownershipFailure('conflict', 'clear the released agent.md statement before binding the same owner');
             if (operation !== 'bind') {
                 const consensus = await this.deps.files.checkConsensus(subAid);
@@ -999,6 +1025,8 @@ export class OwnershipWorkflow {
             if (record.local_decision !== 'pending') {
                 if (record.local_decision !== decision)
                     throw ownershipFailure('conflict', 'the persisted local approval cannot be changed');
+                if (decision === 'accept' && record.status === 'stopped' && record.operation === 'transfer' && this.local() === record.sub_aid && record.step === 'agent' && record.code === 'conflict' && record.reason === 'conflict: target owner declaration does not match this task' && !await this.recoverTargetDeclaration(handle))
+                    return ownershipTaskResult(record);
                 await this.drive(handle);
                 return ownershipTaskResult(record);
             }
@@ -1007,12 +1035,13 @@ export class OwnershipWorkflow {
             if (record.status !== 'pending')
                 throw ownershipFailure('conflict', 'ownership approval stage has ended');
             const ns = await this.readNs(record.sub_aid);
-            if (ns.relation_version !== record.base_relation_version || (record.operation === 'bind' ? ns.lock !== 'unlocked' : ns.lock !== 'locked' || ns.owner_aid !== record.owner_aid))
+            if (!this.isBase(record, ns))
                 throw ownershipFailure('conflict', 'the original relation changed before approval');
             await this.assertBaseMaterial(handle, ns);
             record.local_decision = decision;
             record.approvals[this.local()] = decision;
-            this.enqueue(record, record.initiator_aid, `${record.operation}.${decision === 'accept' ? 'accept' : 'reject'}`, reason);
+            if (decision !== 'accept' || !this.ownerFirst(record))
+                this.enqueue(record, record.initiator_aid, `${record.operation}.${decision === 'accept' ? 'accept' : 'reject'}`, reason);
             if (decision === 'reject') {
                 record.status = 'rejected';
                 record.step = 'approval';
@@ -1026,6 +1055,42 @@ export class OwnershipWorkflow {
             return ownershipTaskResult(record);
         });
     }
+    async recoverTargetDeclaration(handle) {
+        const record = handle.record, local = this.local(), base = record.base_agent_md;
+        if (!base || record.new_owner_aid === local || record.files.agent || record.files.owner || record.owner_proposal || record.legacy_task || record.legacy_recovery || record.approvals[local] !== 'accept' || record.authorization_sha256 === undefined || record.expires_at === undefined)
+            return false;
+        const began = Date.now();
+        const sameBase = (ns) => this.isBase(record, ns) && ns.exists === base.exists && ns.content === base.raw && ownershipSha256(ns.content) === base.sha256 && ns.etag === base.etag;
+        try {
+            if (!sameBase(await this.readNs(record.sub_aid)))
+                return false;
+            await this.deps.files.requireTransfer(this.fileTask(handle));
+            const target = await this.deps.files.readOwner(targetOwner(record), record.sub_aid);
+            if (!target.exists)
+                return false;
+            const declaration = await this.deps.files.verifyFile(target.content, 'owner', record.sub_aid, targetOwner(record));
+            if (declaration.action !== 'declare' || declaration.statement.relation_version !== record.target_relation_version)
+                return false;
+            if (!sameBase(await this.readNs(record.sub_aid)))
+                return false;
+            await this.deps.files.requireTransfer(this.fileTask(handle));
+            const after = await this.deps.files.readOwner(targetOwner(record), record.sub_aid);
+            if (!after.exists || after.content !== target.content || after.sha256 !== target.sha256 || after.version !== target.version || after.revision !== target.revision || Date.now() - began > 30_000 || this.local() !== local)
+                return false;
+            this.assertActive(handle);
+        }
+        catch (error) {
+            if (error instanceof StateError && error.stringCode === 'persistence_unavailable')
+                throw error;
+            return false;
+        }
+        record.status = 'pending';
+        record.retryable = true;
+        delete record.code;
+        delete record.reason;
+        await this.save(handle);
+        return true;
+    }
     enqueue(record, to, action, reason) {
         if (to === this.local())
             return;
@@ -1038,11 +1103,13 @@ export class OwnershipWorkflow {
             payload.new_owner_aid = record.new_owner_aid;
         if (reason !== undefined)
             payload.reason = reason;
-        record.outbox.push({ to, payload });
+        record.outbox.push({ to, payload, message_id: `m-${randomUUID().replace(/-/g, '')}` });
         record.notices.push(key);
     }
     validateOutgoing(record, item) {
         try {
+            if (item.message_id !== undefined && (typeof item.message_id !== 'string' || !/^m-[0-9a-f]{32}$/.test(item.message_id)))
+                throw new Error('ownership outgoing message_id is corrupt');
             const message = parseOwnershipMessage(item.payload, { authenticated_from_aid: this.local(), local_aid: item.to, task: { ...record, local_decision: 'accept' } });
             const rejected = ['bind.reject', 'transfer.reject'].includes(message.action);
             if (message.action !== 'operation.stopped' && record.local_decision !== (rejected ? 'reject' : 'accept') || record.approvals[this.local()] !== record.local_decision)
@@ -1067,10 +1134,10 @@ export class OwnershipWorkflow {
                 continue;
             }
             const ns = await this.readNs(record.sub_aid);
-            const base = ns.relation_version === record.base_relation_version && (record.operation === 'bind' ? ns.lock === 'unlocked' && !ns.owner_aid : ns.lock === 'locked' && ns.owner_aid === record.owner_aid);
+            const base = this.isBase(record, ns);
             const target = record.operation === 'release' ? ns.lock === 'unlocked' && !ns.owner_aid && (ns.relation_version === record.base_relation_version || ns.relation_version === 0) : ns.relation_version === record.target_relation_version && ns.lock === 'locked' && ns.owner_aid === targetOwner(record);
             const requiresTarget = ['relation.confirmed', 'sub.cleaned'].includes(message.payload.action);
-            if (requiresTarget ? !target : !base) {
+            if (requiresTarget ? !target : !base && !(record.operation === 'bind' && target && ['owner.ready', 'bind.accept'].includes(message.payload.action))) {
                 record.outbox.shift();
                 await this.save(handle);
                 continue;
@@ -1084,8 +1151,12 @@ export class OwnershipWorkflow {
                 if (expiresAt <= Math.trunc(Date.now() / 1000))
                     throw ownershipFailure('conflict', 'transfer authorization expired');
             }
+            if (!message.message_id) {
+                message.message_id = `m-${randomUUID().replace(/-/g, '')}`;
+                await this.save(handle);
+            }
             this.assertActive(handle);
-            await this.deps.send(message.to, message.payload);
+            await this.deps.send(message.to, message.payload, message.message_id);
             handle.record.outbox.shift();
             await this.save(handle);
         }
@@ -1098,11 +1169,35 @@ export class OwnershipWorkflow {
         const currentOwner = ns.lock === 'locked' ? file?.statement?.owner_aid : null;
         if (ns.lock === 'locked' && (!file?.statement || file.statement.relation_version !== ns.relation_version) || ns.owner_aid !== undefined && ns.owner_aid !== currentOwner)
             throw ownershipFailure('unavailable', 'NS owner metadata and signed agent.md do not agree', true);
-        return { ...ns, owner_aid: currentOwner };
+        if (!file?.statement)
+            return { ...ns, owner_aid: currentOwner };
+        const consensus = await this.deps.files.checkConsensus(subAid);
+        if (consensus.status === 'invalid' || consensus.status === 'unavailable' || consensus.status === 'not_applicable')
+            throw ownershipFailure(consensus.code ?? consensus.status, consensus.reason ?? 'ownership materials cannot be verified', consensus.retryable);
+        if (consensus.relation_version !== ns.relation_version || consensus.agent_md_etag !== ns.etag || consensus.agent_md_sha256 !== ownershipSha256(ns.content))
+            throw ownershipFailure('unavailable', 'agent.md changed during ownership verification', true);
+        return { ...ns, lock: consensus.lock, owner_aid: consensus.owner_aid };
+    }
+    isPending(record, ns) {
+        if (record.operation !== 'bind' || ns.lock !== 'unlocked' || !(ns.pending || ns.ownership_status === 'pending') || ns.relation_version !== record.target_relation_version)
+            return false;
+        const saved = record.files.agent;
+        const candidate = saved ? { raw: saved.raw, sha256: saved.hash, etag: saved.published_etag } : record.pending_agent_md ?? (record.base_agent_md?.pending ? record.base_agent_md : undefined);
+        return Boolean(candidate && ns.content === candidate.raw && ownershipSha256(ns.content) === candidate.sha256 && (!candidate.etag || ns.etag === candidate.etag));
+    }
+    isPendingBase(record, ns) {
+        const base = record.base_agent_md;
+        return record.operation === 'bind' && Boolean(base?.pending) && ns.lock === 'unlocked' && (ns.pending || ns.ownership_status === 'pending') && ns.relation_version === record.base_relation_version && ns.content === base.raw && ns.etag === base.etag && ownershipSha256(ns.content) === base.sha256;
+    }
+    isBase(record, ns) {
+        return this.isPending(record, ns) || this.isPendingBase(record, ns) || ns.relation_version === record.base_relation_version && (record.operation === 'bind' ? ns.lock === 'unlocked' && !ns.owner_aid : ns.lock === 'locked' && ns.owner_aid === record.owner_aid);
     }
     async captureBase(record, ns) {
         const statement = ns.exists ? parseOwnershipFile(ns.content, 'agent', { expectedSubAid: record.sub_aid }).statement ?? null : null;
-        record.base_agent_md = { exists: ns.exists, raw: ns.content, sha256: ownershipSha256(ns.content), etag: ns.etag, statement };
+        const pending = record.operation === 'bind' && (ns.pending || ns.ownership_status === 'pending') && ns.relation_version === record.target_relation_version && statement?.owner_aid === record.owner_aid;
+        record.base_agent_md = { exists: ns.exists, raw: ns.content, sha256: ownershipSha256(ns.content), etag: ns.etag, statement, ...(record.operation === 'bind' && (ns.pending || ns.ownership_status === 'pending') ? { pending: true } : {}) };
+        if (pending)
+            record.pending_agent_md = { raw: ns.content, sha256: ownershipSha256(ns.content), etag: ns.etag };
         if (!statement) {
             record.base_owner_md = { exists: false, raw: '', sha256: '' };
             return;
@@ -1117,6 +1212,12 @@ export class OwnershipWorkflow {
     async assertBaseMaterial(handle, ns) {
         const record = handle.record;
         this.assertAgentBaseMaterial(record, ns);
+        if (record.owner_proposal) {
+            const current = await this.deps.files.readOwner(record.owner_aid, record.sub_aid);
+            if (!current.exists || current.content !== record.owner_proposal.raw || current.sha256 !== record.owner_proposal.sha256)
+                throw ownershipFailure('conflict', 'owner binding proposal changed');
+            await this.deps.files.verifyFile(current.content, 'owner', record.sub_aid, record.owner_aid);
+        }
         const original = record.base_owner_md;
         if (!original)
             throw ownershipFailure('persistence_unavailable', 'original owner.md evidence is missing');
@@ -1148,9 +1249,13 @@ export class OwnershipWorkflow {
         throw ownershipFailure('conflict', 'the original owner statement was replaced');
     }
     assertAgentBaseMaterial(record, ns) {
+        if (this.isPending(record, ns))
+            return;
         const base = record.base_agent_md;
         if (!base || typeof base.raw !== 'string')
             throw ownershipFailure('persistence_unavailable', 'original agent.md evidence is missing');
+        if (base.pending && (ns.content !== base.raw || ns.etag !== base.etag))
+            throw ownershipFailure('conflict', 'the pending ownership original was replaced');
         const statement = ns.exists ? parseOwnershipFile(ns.content, 'agent', { expectedSubAid: record.sub_aid }).statement ?? null : null;
         const same = base.statement ? Boolean(statement && Object.keys(base.statement).every((key) => base.statement[key] === statement[key])) : statement === null && ns.content === base.raw && ownershipSha256(ns.content) === base.sha256;
         if (ns.exists !== base.exists || !same)
@@ -1161,6 +1266,10 @@ export class OwnershipWorkflow {
         while (record.inbox.length) {
             const item = record.inbox[0];
             const ns = await this.readNs(record.sub_aid);
+            if (record.operation === 'bind' && record.request_verified && !record.pending_agent_md && item.payload.action === 'bind.accept' && item.from === record.sub_aid && (ns.pending || ns.ownership_status === 'pending') && ns.lock === 'unlocked' && ns.relation_version === record.target_relation_version && parseOwnershipFile(ns.content, 'agent', { expectedSubAid: record.sub_aid }).statement?.owner_aid === record.owner_aid) {
+                record.pending_agent_md = { raw: ns.content, sha256: ownershipSha256(ns.content), etag: ns.etag };
+                await this.save(handle);
+            }
             if (record.request_verified && ns.relation_version === record.base_relation_version && !['relation.confirmed', 'sub.cleaned'].includes(item.payload.action))
                 await this.assertBaseMaterial(handle, ns);
             try {
@@ -1191,6 +1300,17 @@ export class OwnershipWorkflow {
                 record.legacy_recovery.owner_confirmed = true;
             }
             if (['bind.request', 'transfer.request'].includes(action)) {
+                if (this.ownerFirst(record)) {
+                    if (ns.lock !== 'unlocked' || ns.pending || ns.ownership_status === 'pending')
+                        throw ownershipFailure('conflict', 'owner binding requires the original unlocked relation');
+                    const proposal = await this.deps.files.readOwner(record.owner_aid, record.sub_aid);
+                    if (!proposal.exists)
+                        throw ownershipFailure('unavailable', 'owner binding proposal is missing', true);
+                    const file = await this.deps.files.verifyFile(proposal.content, 'owner', record.sub_aid, record.owner_aid);
+                    if (file.action !== 'declare' || file.statement?.relation_version !== record.target_relation_version || record.owner_proposal && (record.owner_proposal.raw !== proposal.content || record.owner_proposal.sha256 !== proposal.sha256))
+                        throw ownershipFailure('conflict', 'owner binding proposal does not match this operation');
+                    record.owner_proposal = { raw: proposal.content, sha256: proposal.sha256 };
+                }
                 if (!record.request_verified)
                     await this.captureBase(record, ns);
                 record.request_verified = true;
@@ -1309,8 +1429,9 @@ export class OwnershipWorkflow {
     fileTask(handle) {
         const record = handle.record;
         const task = { operation_id: record.operation_id, operation: record.operation, sub_aid: record.sub_aid, owner_aid: record.owner_aid,
+            stage: record.operation === 'bind' && record.initiator_aid === record.sub_aid && !record.legacy_recovery && !record.legacy_task,
             new_owner_aid: record.new_owner_aid, base_relation_version: record.base_relation_version, target_relation_version: record.target_relation_version,
-            files: record.files, authorization_sha256: record.authorization_sha256, expires_at: record.expires_at, base_agent_md: record.base_agent_md, base_owner_md: record.base_owner_md,
+            files: record.files, authorization_sha256: record.authorization_sha256, expires_at: record.expires_at, base_agent_md: record.base_agent_md, base_owner_md: record.base_owner_md, pending_agent_md: record.pending_agent_md, owner_proposal: record.owner_proposal,
             assertActive: () => this.assertActive(handle),
             persist: async () => {
                 record.authorization_sha256 = task.authorization_sha256;
@@ -1326,6 +1447,9 @@ export class OwnershipWorkflow {
         if (!current || this.isReset(current.record) || current.revision !== handle.revision)
             throw ownershipFailure('conflict', 'ownership task changed before external action');
     }
+    ownerFirst(record) {
+        return record.operation === 'bind' && record.initiator_aid === record.owner_aid && record.owner_aid !== record.sub_aid && Boolean(record.owner_first || record.owner_proposal) && !record.legacy_recovery && !record.legacy_task;
+    }
     async drive(handle) {
         if (this.isReset(handle.record))
             return;
@@ -1339,7 +1463,34 @@ export class OwnershipWorkflow {
         }
         try {
             await this.processInbox(handle);
+            if (this.ownerFirst(record) && record.status === 'pending' && record.request_verified && this.local() === record.owner_aid) {
+                const ns = await this.readNs(record.sub_aid);
+                if (this.isBase(record, ns)) {
+                    await this.assertBaseMaterial(handle, ns);
+                    record.step = 'owner';
+                    await this.save(handle);
+                    await this.deps.files.declareSubaid(this.fileTask(handle));
+                }
+            }
+            if (record.operation === 'bind' && (record.initiator_aid === record.sub_aid || this.ownerFirst(record)) && record.status === 'pending' && record.request_verified && record.local_decision === 'accept' && this.local() === record.sub_aid && !record.legacy_recovery && !record.legacy_task) {
+                record.step = 'agent';
+                await this.save(handle);
+                await this.deps.files.declareOwneraid(this.fileTask(handle));
+            }
             await this.flush(handle);
+            if (this.ownerFirst(record) && record.status === 'rejected' && this.local() === record.owner_aid && record.files.owner)
+                await this.deps.files.cancelOwnerProposal(this.fileTask(handle));
+            if (record.operation === 'bind' && record.status === 'rejected' && this.local() === record.sub_aid && record.files.agent && !record.rejection_cleanup?.cleaned) {
+                if (!record.rejection_cleanup) {
+                    record.rejection_cleanup = { files: {}, cleaned: false };
+                    await this.save(handle);
+                }
+                const task = this.fileTask(handle);
+                task.files = record.rejection_cleanup.files;
+                await this.deps.files.cancelPendingBind(task, record.files.agent);
+                record.rejection_cleanup.cleaned = true;
+                await this.save(handle);
+            }
             if (record.status === 'rejected' || record.status === 'stopped' || record.status === 'error')
                 return;
             if (!record.request_verified)
@@ -1376,7 +1527,7 @@ export class OwnershipWorkflow {
                 return;
             }
             const ns = await this.readNs(record.sub_aid);
-            if (ns.relation_version !== record.base_relation_version || record.operation === 'bind' && ns.lock !== 'unlocked' || record.operation === 'transfer' && (ns.lock !== 'locked' || ns.owner_aid !== record.owner_aid)) {
+            if (!this.isBase(record, ns)) {
                 throw ownershipFailure('conflict', 'the original relation was replaced');
             }
             await this.assertBaseMaterial(handle, ns);
@@ -1412,7 +1563,8 @@ export class OwnershipWorkflow {
                 record.step = 'owner';
                 await this.save(handle);
                 await this.deps.files.declareSubaid(this.fileTask(handle));
-                this.enqueue(record, record.sub_aid, 'owner.ready');
+                if (!this.ownerFirst(record))
+                    this.enqueue(record, record.sub_aid, 'owner.ready');
                 await this.save(handle);
                 await this.flush(handle);
             }
@@ -1512,6 +1664,10 @@ export class OwnershipWorkflow {
         }
         if (record.operation !== 'release' && (record.local_decision !== 'accept' || this.local() === record.sub_aid && (!record.files.agent || record.files.agent.hash !== result.agent_md_sha256) || this.local() === targetOwner(record) && (!record.files.owner || record.files.owner.hash !== result.owner_md_sha256)))
             return false;
+        if (record.owner_proposal && record.owner_proposal.sha256 !== result.owner_md_sha256)
+            throw ownershipFailure('conflict', 'owner binding proposal changed before acceptance');
+        if (record.operation === 'bind' && record.pending_agent_md && (record.pending_agent_md.sha256 !== result.agent_md_sha256 || record.pending_agent_md.etag !== result.agent_md_etag))
+            throw ownershipFailure('conflict', 'pending ownership original changed before acceptance');
         if (record.status !== 'completed' && record.operation !== 'release' && this.local() === record.sub_aid && record.files.agent?.published_etag !== undefined && record.files.agent.published_etag !== result.agent_md_etag)
             throw ownershipFailure('conflict', 'published agent.md ETag changed');
         if (record.status !== 'completed') {