@agentunion/fastaun-browser 0.5.19 → 0.5.21

package/dist/ownership-workflow.js

@@ -27,6 +27,14 @@ export function parseOwnershipRegistrationIntent(raw, aid) {
 function failure(code, reason, retryable = false) {
     return new StateError(reason, { stringCode: code, retryable });
 }
+function storageFailure(reason) {
+    return Object.assign(failure('persistence_unavailable', reason), { ownershipStorageFailure: true });
+}
+function rawTaskRecord(snapshot) {
+    const raw = Object.hasOwn(snapshot, 'raw') ? snapshot.raw : snapshot;
+    const record = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw.record : undefined;
+    return record && typeof record === 'object' && !Array.isArray(record) ? record : undefined;
+}
 function participants(task) {
     return [...new Set([task.owner_aid, task.sub_aid, ...(task.new_owner_aid ? [task.new_owner_aid] : [])])];
 }
@@ -81,8 +89,9 @@ export function parseOwnershipMessage(content) {
     ownershipAid(message.sub_aid, 'sub_aid');
     ownershipAid(message.owner_aid, 'owner_aid');
     ownershipInteger(message.base_relation_version, 'base_relation_version', 0);
-    if (ownershipInteger(message.target_relation_version, 'target_relation_version') !== message.base_relation_version + 1)
-        throw new ValidationError('ownership target version must be base plus one');
+    const target = ownershipInteger(message.target_relation_version, 'target_relation_version');
+    if (target !== message.base_relation_version + 1 && !(message.operation === 'release' && target === message.base_relation_version))
+        throw new ValidationError('ownership target version does not match operation');
     if (message.operation === 'transfer') {
         if (ownershipAid(message.new_owner_aid, 'new_owner_aid') === message.owner_aid)
             throw new ValidationError('transfer target must differ from current owner');
@@ -148,8 +157,9 @@ export function validateOwnershipMessage(message, context) {
         if (ns.protocol !== '2.1')
             throw failure('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 target = ns.relation_version === message.target_relation_version && (message.operation === 'release' ? ns.lock === 'unlocked' && !ns.owner_aid : ns.lock === 'locked' && ns.owner_aid === targetOwner(message));
-        if (message.action !== 'operation.stopped' && (['relation.confirmed', 'sub.cleaned'].includes(message.action) ? !target : !base && !target))
+        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);
+        const cleaned = message.action === 'sub.cleaned' && Boolean(task) && ns.relation_version === 0 && ns.lock === 'unlocked' && !ns.owner_aid;
+        if (message.action !== 'operation.stopped' && (['relation.confirmed', 'sub.cleaned'].includes(message.action) ? !target && !cleaned : !base && !target))
             throw failure('conflict', 'ownership current NS relation does not match this task');
     }
 }
@@ -199,7 +209,7 @@ export class OwnershipWorkflow {
         const store = this.deps.store;
         for (const name of ['loadOwnershipTask', 'listOwnershipTasks', 'compareAndSwapOwnershipTask', 'acquireOwnershipTaskLease', 'renewOwnershipTaskLease', 'releaseOwnershipTaskLease']) {
             if (typeof store[name] !== 'function')
-                throw failure('persistence_unavailable', 'ownership durable task storage is unavailable');
+                throw storageFailure('ownership durable task storage is unavailable');
         }
         return store;
     }
@@ -208,17 +218,21 @@ export class OwnershipWorkflow {
             return await this.storage().loadOwnershipTask(aid, operationId);
         }
         catch (error) {
-            throw failure('persistence_unavailable', `ownership task read failed: ${String(error)}`);
+            throw storageFailure(`ownership task read failed: ${String(error)}`);
         }
     }
-    async record(snapshot) {
+    async record(snapshot, legacy = false) {
         const task = snapshot.record;
+        if (snapshot.record.reset === true && snapshot.revision > 0)
+            throw failure('conflict', 'ownership operation was reset');
         const localAid = this.deps.currentAid();
         try {
+            if (!Number.isSafeInteger(snapshot.revision) || snapshot.revision < 1)
+                throw new Error('invalid persisted task revision');
             if (task.schema_version !== 1 || !['pending', 'completed', 'rejected', 'stopped', 'error'].includes(task.status) || !['pending', 'accept', 'reject'].includes(task.local_decision) || typeof task.step !== 'string')
                 throw new Error('invalid task state');
             parseOwnershipMessage({ ...this.message(task, task.operation === 'bind' ? 'bind.request' : task.operation === 'transfer' ? 'transfer.request' : 'relation.confirmed') });
-            if (!participants(task).includes(task.initiator_aid) || JSON.stringify(task.local_roles) !== JSON.stringify(ownershipLocalRoles(task, localAid)) || !task.local_roles.length)
+            if (!participants(task).includes(task.initiator_aid) || task.operation !== 'bind' && task.initiator_aid !== task.owner_aid || JSON.stringify(task.local_roles) !== JSON.stringify(ownershipLocalRoles(task, localAid)) || !task.local_roles.length)
                 throw new Error('invalid local task identity');
             if (!task.approvals || typeof task.approvals !== 'object' || Array.isArray(task.approvals) || Object.entries(task.approvals).some(([aid, decision]) => !participants(task).includes(aid) || !['pending', 'accept', 'reject'].includes(decision)))
                 throw new Error('invalid task approvals');
@@ -226,6 +240,54 @@ export class OwnershipWorkflow {
                 throw new Error('incomplete task approvals or initiator decision');
             if (!task.files || typeof task.files !== 'object' || Array.isArray(task.files) || !Array.isArray(task.inbox) || !Array.isArray(task.received) || !Array.isArray(task.outbox) || !Array.isArray(task.sent) || !task.hints || typeof task.hints !== 'object' || typeof task.request_validated !== 'boolean')
                 throw new Error('invalid task journals');
+            if (!task.base_agent_md && task.request_validated && !legacy && !task.legacy_task)
+                return task;
+            if (task.legacy_recovery) {
+                const recovery = task.legacy_recovery, original = recovery.task;
+                await this.validateLegacyBind(original);
+                if (!Number.isSafeInteger(recovery.revision) || recovery.revision < 1 || recovery.revision >= snapshot.revision || recovery.task_sha256 !== await ownershipSha256(JSON.stringify(original)) || !this.sameIntent(task, original) || task.operation_id !== original.operation_id || task.base_relation_version !== original.base_relation_version || task.target_relation_version !== original.target_relation_version || task.created_at !== original.created_at || task.local_decision !== original.local_decision && original.local_decision !== 'pending' || Object.entries(original.approvals).some(([aid, decision]) => decision !== 'pending' && task.approvals[aid] !== decision) || !recovery.checkpoint || !Number.isSafeInteger(recovery.checkpoint.observed_at) || typeof recovery.owner_confirmed !== 'boolean')
+                    throw new Error('invalid legacy recovery checkpoint');
+                const owner = recovery.checkpoint.owner_md;
+                if (!owner || typeof owner.exists !== 'boolean' || typeof owner.raw !== 'string' || owner.sha256 !== (owner.exists ? await ownershipSha256(owner.raw) : '') || !owner.exists && owner.raw !== '')
+                    throw new Error('invalid legacy owner checkpoint');
+                if (task.local_roles.includes('sub') && (owner.exists || recovery.owner_confirmed) && (!task.files.owner || owner.exists && (task.files.owner.raw !== owner.raw || task.files.owner.sha256 !== owner.sha256)))
+                    throw new Error('missing or changed legacy owner candidate');
+            }
+            if (task.legacy_task) {
+                const recovery = task.legacy_task, original = recovery.task;
+                if (!Number.isSafeInteger(recovery.revision) || recovery.revision < 1 || recovery.revision >= snapshot.revision || recovery.task_sha256 !== await ownershipSha256(JSON.stringify(original)))
+                    throw new Error('invalid legacy task source');
+                await this.priorView(original);
+                if (!this.sameIntent(task, original) || task.operation_id !== original.operation_id || task.base_relation_version !== original.base_relation_version || task.target_relation_version !== original.target_relation_version || task.created_at !== original.created_at || Object.entries(original.approvals).some(([aid, decision]) => decision !== 'pending' && task.approvals[aid] !== decision) || JSON.stringify(recovery.checkpoint.agent_md) !== JSON.stringify(task.base_agent_md ?? null) || JSON.stringify(recovery.checkpoint.owner_md) !== JSON.stringify(task.base_owner_md ?? null) || !task.base_agent_md && task.status !== 'completed')
+                    throw new Error('legacy task fixed context changed');
+                for (const [key, prepared] of Object.entries(original.files))
+                    if (task.files[key]?.raw !== prepared.raw || task.files[key]?.sha256 !== prepared.sha256 || ['agent', 'cleanup'].includes(key) && JSON.stringify(task.files[key]?.condition) !== JSON.stringify(prepared.condition))
+                        throw new Error('legacy task signed candidate changed');
+            }
+            const base = task.base_agent_md;
+            if (!base && !legacy && !task.legacy_task && (task.request_validated || Object.keys(task.files).length || task.local_decision !== 'pending'))
+                throw new Error('missing original agent.md context');
+            if (base) {
+                if (typeof base.exists !== 'boolean' || typeof base.raw !== 'string' || typeof base.etag !== 'string' || base.exists && !base.etag || base.sha256 !== await ownershipSha256(base.raw))
+                    throw new Error('invalid original agent.md bytes or ETag');
+                const statement = base.exists ? parseOwnershipFile(base.raw, 'agent', { expectedSubAid: task.sub_aid }).statement : undefined;
+                if ((statement?.relation_version ?? 0) !== task.base_relation_version || statement && task.operation !== 'bind' && statement.owner_aid !== task.owner_aid || (statement ? !this.sameStatement(statement, base.statement ?? undefined) : base.statement !== null))
+                    throw new Error('invalid original agent.md statement');
+            }
+            if (task.base_owner_md) {
+                const prior = task.base_owner_md;
+                if (typeof prior.exists !== 'boolean' || typeof prior.raw !== 'string' || prior.sha256 !== (prior.exists ? await ownershipSha256(prior.raw) : '') || !prior.exists && prior.raw !== '')
+                    throw new Error('invalid original owner.md context');
+                if (base?.statement && !prior.exists && (task.operation === 'transfer' || task.operation === 'release' && task.local_roles.includes('owner')))
+                    throw new Error('missing original owner.md relation');
+                if (prior.exists) {
+                    const file = parseOwnershipFile(prior.raw, 'owner', { expectedSubAid: task.sub_aid });
+                    if (!file.statement || file.statement.owner_aid !== base?.statement?.owner_aid || file.statement.relation_version !== base?.statement?.relation_version)
+                        throw new Error('invalid original owner.md statement');
+                }
+            }
+            if (base?.statement && !task.base_owner_md && !(task.operation === 'release' && task.local_roles.includes('sub') && !task.local_roles.includes('owner') && task.cleanup_authorization_operation_id && !task.files.cleanup))
+                throw new Error('missing original owner.md context');
             if (task.approvals[localAid] !== task.local_decision)
                 throw new Error('task decision and approval differ');
             if (task.status === 'completed' && (task.verified_relation_version !== task.target_relation_version || task.operation !== 'release' && task.local_decision !== 'accept'))
@@ -239,20 +301,23 @@ export class OwnershipWorkflow {
                 if (!['agent', 'owner', 'release', 'transfer', 'cleanup'].includes(key) || !prepared || typeof prepared.raw !== 'string' || !/^[0-9a-f]{64}$/.test(prepared.sha256) || await ownershipSha256(prepared.raw) !== prepared.sha256 || !prepared.condition || typeof prepared.condition !== 'object' || Array.isArray(prepared.condition))
                     throw new Error('invalid prepared file bytes');
                 const condition = prepared.condition;
-                if (Object.keys(condition).length !== 1 || (agentFile ? !(typeof condition.if_match === 'string' && condition.if_match || condition.if_none_match === '*') : typeof condition.expected_revision !== 'string' || !condition.expected_revision))
+                if (agentFile ? Object.keys(condition).length !== 1 || !(typeof condition.if_match === 'string' && condition.if_match || condition.if_none_match === '*') : Object.keys(condition).length !== 0)
                     throw new Error('invalid prepared file condition');
+                const original = prepared.original_owner;
+                if (!agentFile && (!original || typeof original.exists !== 'boolean' || typeof original.raw !== 'string' || original.sha256 !== (original.exists ? await ownershipSha256(original.raw) : '') || !original.exists && original.raw !== ''))
+                    throw new Error('invalid prepared owner original');
                 if (key === 'cleanup' && task.operation !== 'release' || key === 'release' && task.operation !== 'release' || key === 'transfer' && task.operation !== 'transfer' || ['agent', 'owner'].includes(key) && task.operation === 'release')
                     throw new Error('invalid prepared file operation');
                 const ownerAid = key === 'owner' || key === 'agent' ? targetOwner(task) : task.owner_aid;
                 const file = parseOwnershipFile(prepared.raw, agentFile ? 'agent' : 'owner', { expectedSubAid: task.sub_aid, expectedOwnerAid: key === 'cleanup' ? undefined : ownerAid });
-                if (!task.local_roles.includes(agentFile ? 'sub' : key === 'owner' && task.operation === 'transfer' ? 'new_owner' : 'owner'))
+                if (!task.local_roles.includes(agentFile ? 'sub' : key === 'owner' && task.operation === 'transfer' ? 'new_owner' : 'owner') && !(key === 'owner' && task.legacy_recovery && task.local_roles.includes('sub')))
                     throw new Error('invalid prepared file local role');
                 if (key === 'cleanup' ? Boolean(file.statement) : file.statement?.relation_version !== (key === 'owner' || key === 'agent' ? task.target_relation_version : task.base_relation_version))
                     throw new Error('invalid prepared file generation');
                 const fileExpiry = prepared.expires_at;
                 if (!agentFile && file.action !== (key === 'owner' ? 'declare' : key === 'release' ? 'release' : 'transfer_owner') || key === 'transfer' && (typeof fileExpiry !== 'number' || !Number.isSafeInteger(fileExpiry) || fileExpiry <= 0 || fileExpiry !== task.expires_at || file.transfer?.new_owner_aid !== task.new_owner_aid || file.transfer?.target_relation_version !== task.target_relation_version || file.transfer?.expires_at !== fileExpiry) || key !== 'transfer' && fileExpiry !== undefined)
                     throw new Error('invalid prepared file authorization');
-                if (prepared.published_revision !== undefined && (agentFile || typeof prepared.published_revision !== 'string' || !prepared.published_revision) || prepared.published_etag !== undefined && (!agentFile || typeof prepared.published_etag !== 'string' || !prepared.published_etag) || prepared.cleaned !== undefined && typeof prepared.cleaned !== 'boolean')
+                if (prepared.published_etag !== undefined && (!agentFile || typeof prepared.published_etag !== 'string' || !prepared.published_etag) || prepared.cleaned !== undefined && typeof prepared.cleaned !== 'boolean')
                     throw new Error('invalid prepared file result');
             }
             if (task.release_cleanup !== undefined) {
@@ -266,19 +331,27 @@ export class OwnershipWorkflow {
             }
             if (task.status === 'completed') {
                 const consensus = task.verified_consensus;
-                if (!consensus || consensus.protocol !== '2.1' || consensus.sub_aid !== task.sub_aid || consensus.relation_version !== task.target_relation_version || typeof consensus.agent_md_etag !== 'string' || !consensus.agent_md_etag || !/^[0-9a-f]{64}$/.test(consensus.agent_md_sha256))
+                const cleaned = task.operation === 'release' && consensus?.status === 'unbound' && consensus.relation_version === 0 && Boolean(await this.cleanupEvidence(task, consensus));
+                if (!consensus || consensus.protocol !== '2.1' || consensus.sub_aid !== task.sub_aid || !cleaned && consensus.relation_version !== (task.operation === 'release' ? task.base_relation_version : task.target_relation_version) || typeof consensus.agent_md_etag !== 'string' || !consensus.agent_md_etag || !/^[0-9a-f]{64}$/.test(consensus.agent_md_sha256))
                     throw new Error('invalid persisted consensus evidence');
                 if (task.operation === 'release') {
-                    if (consensus.status !== 'released' || consensus.lock !== 'unlocked' || consensus.owner_aid !== null || task.local_roles.includes('owner') && !task.files.release)
+                    if (!cleaned && consensus.status !== 'released' || consensus.lock !== 'unlocked' || consensus.owner_aid !== null || task.local_roles.includes('owner') && !task.files.release)
                         throw new Error('invalid persisted release evidence');
                 }
                 else {
-                    if (consensus.status !== 'consensus' || consensus.lock !== 'locked' || consensus.owner_aid !== targetOwner(task) || typeof consensus.owner_md_revision !== 'string' || !consensus.owner_md_revision || !/^[0-9a-f]{64}$/.test(consensus.owner_md_sha256))
+                    if (consensus.status !== 'consensus' || consensus.lock !== 'locked' || consensus.owner_aid !== targetOwner(task) || !/^[0-9a-f]{64}$/.test(consensus.owner_md_sha256))
                         throw new Error('invalid persisted binding evidence');
-                    if (task.local_roles.includes('sub') && task.files.agent?.sha256 !== consensus.agent_md_sha256 || task.local_roles.includes(task.operation === 'transfer' ? 'new_owner' : 'owner') && task.files.owner?.sha256 !== consensus.owner_md_sha256 || task.operation === 'transfer' && task.local_roles.includes('owner') && !task.files.transfer)
+                    if (task.local_roles.includes('sub') && task.files.agent?.sha256 !== consensus.agent_md_sha256 || (task.local_roles.includes(task.operation === 'transfer' ? 'new_owner' : 'owner') || task.legacy_recovery && task.local_roles.includes('sub')) && task.files.owner?.sha256 !== consensus.owner_md_sha256 || task.operation === 'transfer' && task.local_roles.includes('owner') && !task.files.transfer)
                         throw new Error('persisted consensus differs from local original files');
                 }
             }
+            for (const key of task.received) {
+                if (typeof key !== 'string' || key.split('|').length !== 2)
+                    throw new Error('invalid received journal');
+                const [fromAid, action] = key.split('|');
+                const message = parseOwnershipMessage(this.message(task, action));
+                validateOwnershipMessage(message, { authenticated_from_aid: fromAid, local_aid: localAid, task });
+            }
             for (const item of task.inbox) {
                 parseOwnershipMessage(item.payload);
                 validateOwnershipMessage(item.payload, { authenticated_from_aid: item.from_aid, local_aid: localAid, task });
@@ -287,6 +360,11 @@ export class OwnershipWorkflow {
             }
             for (const item of task.outbox) {
                 parseOwnershipMessage(item.payload);
+                const action = item.payload.action;
+                if (['bind.accept', 'transfer.accept', 'owner.ready', 'transfer.ready'].includes(action) && task.local_decision !== 'accept' || ['bind.reject', 'transfer.reject'].includes(action) && task.local_decision !== 'reject')
+                    throw new Error('invalid outbox local approval');
+                if (['bind.accept', 'transfer.accept', 'bind.reject', 'transfer.reject'].includes(action) && !task.request_validated)
+                    throw new Error('invalid outbox received request');
                 validateOwnershipMessage(item.payload, { authenticated_from_aid: localAid, local_aid: item.to_aid, task });
                 if (item.key !== `${item.to_aid}|${item.payload.action}` || typeof item.message_id !== 'string' || !/^m-[0-9a-f]{32}$/.test(item.message_id))
                     throw new Error('invalid outbox target');
@@ -294,7 +372,9 @@ export class OwnershipWorkflow {
             return task;
         }
         catch (error) {
-            throw failure('persistence_unavailable', `ownership task is damaged: ${String(error)}`);
+            if (error?.ownershipStorageFailure)
+                throw error;
+            throw Object.assign(failure('persistence_unavailable', `ownership task is damaged: ${String(error)}`), { ownershipTaskDamage: true });
         }
     }
     message(task, action, reason) {
@@ -323,7 +403,7 @@ export class OwnershipWorkflow {
     event(context, event, extra = {}) {
         context.events.push({ event, payload: { ...ownershipTaskResult(context.task), initiator_aid: context.task.initiator_aid, local_roles: context.task.local_roles,
                 ...(event === 'ownership.request' ? { requester_aid: context.task.initiator_aid } : {}),
-                ...(context.task.verified_relation_version === undefined ? {} : { relation_version: context.task.verified_relation_version }), ...extra } });
+                ...(context.task.verified_consensus === undefined ? {} : { relation_version: context.task.verified_consensus.relation_version }), ...extra } });
     }
     async save(context) {
         context.guard?.();
@@ -394,22 +474,32 @@ export class OwnershipWorkflow {
                 if (!saved && !initial)
                     throw failure('operation_not_found', 'ownership operation was not found');
                 if (!saved && initial) {
-                    const existing = (await this.records(aid)).find((task) => task.sub_aid === subAid && this.ongoing(task));
+                    const existing = (await this.records(aid, subAid, undefined, true)).find((task) => task.sub_aid === subAid && this.ongoing(task));
                     if (existing) {
                         if (!this.sameIntent(existing, initial) || existing.base_relation_version !== initial.base_relation_version || existing.target_relation_version !== initial.target_relation_version)
                             throw failure('conflict', 'another local operation for this sub is pending');
-                        try {
-                            await store.releaseOwnershipTaskLease(aid, lease);
+                        if (initial.initiator_aid === aid) {
+                            try {
+                                await store.releaseOwnershipTaskLease(aid, lease);
+                            }
+                            catch (error) {
+                                throw failure('persistence_unavailable', `ownership sub lease release failed: ${String(error)}`);
+                            }
+                            return { result: await this.advance(subAid, existing.operation_id, undefined, events, undefined, guard), events: [] };
                         }
-                        catch (error) {
-                            throw failure('persistence_unavailable', `ownership sub lease release failed: ${String(error)}`);
-                        }
-                        return { result: await this.advance(subAid, existing.operation_id, undefined, events, undefined, guard), events: [] };
                     }
                 }
                 context = { aid, task: saved ? await this.record(saved) : initial, revision: saved?.revision ?? null, lease, events: [], guard };
                 if (context.task.sub_aid !== subAid)
                     throw failure('conflict', 'ownership task sub changed');
+                if (saved && !context.task.base_agent_md && context.task.request_validated) {
+                    if (!this.ongoing(context.task))
+                        return { result: ownershipTaskResult(context.task), events: context.events };
+                    if (context.task.operation === 'bind' && context.task.initiator_aid === context.task.sub_aid && context.task.base_relation_version === 0 && context.task.target_relation_version === 1 && Object.keys(context.task.files).every((key) => key === 'owner'))
+                        await this.recoverLegacyBind(context);
+                    else
+                        await this.recoverPrior(context);
+                }
                 if (!saved)
                     await this.save(context);
                 await mutate?.(context);
@@ -435,40 +525,198 @@ export class OwnershipWorkflow {
     sameIntent(task, intent) {
         return task.initiator_aid === intent.initiator_aid && task.operation === intent.operation && task.sub_aid === intent.sub_aid && task.owner_aid === intent.owner_aid && task.new_owner_aid === intent.new_owner_aid;
     }
-    async records(aid) {
+    async records(aid, subAid, operations, strictSub = false) {
         let snapshots;
         try {
-            snapshots = await this.storage().listOwnershipTasks(aid);
+            snapshots = await this.storage().listOwnershipTasks(aid, true);
         }
         catch (error) {
-            throw failure('persistence_unavailable', `ownership task list failed: ${String(error)}`);
+            throw storageFailure(`ownership task list failed: ${String(error)}`);
+        }
+        const records = [];
+        for (const snapshot of snapshots) {
+            if (snapshot.record.reset === true && snapshot.revision > 0)
+                continue;
+            if (subAid && typeof snapshot.record.sub_aid === 'string' && snapshot.record.sub_aid !== subAid)
+                continue;
+            if (operations && typeof snapshot.record.operation === 'string' && !operations.includes(snapshot.record.operation))
+                continue;
+            try {
+                records.push(await this.record(snapshot));
+            }
+            catch (error) {
+                await this.deps.emit('ownership.error', { operation_id: snapshot.record.operation_id, sub_aid: snapshot.record.sub_aid, code: ownershipErrorCode(error), reason: String(error), retryable: false });
+                if (strictSub && snapshot.record.sub_aid === subAid)
+                    throw error;
+            }
         }
-        return await Promise.all(snapshots.map((snapshot) => this.record(snapshot)));
+        return records;
     }
     async observe(subAid) {
         this.requireApplicable(subAid);
         const snapshot = await this.deps.files.readAgent(subAid);
-        const file = snapshot.exists ? snapshot.lock === 'unlocked' && snapshot.relation_version > 0
-            ? parseOwnershipFile(snapshot.content, 'agent', { expectedSubAid: subAid })
-            : await this.deps.files.verify(snapshot.content, 'agent', subAid) : null;
+        const file = snapshot.exists ? await this.deps.files.verify(snapshot.content, 'agent', subAid) : null;
         if (file)
             requireOwnershipApplicable(file.frontmatter.type);
-        if (snapshot.lock === 'unlocked' && snapshot.relation_version === 0 && file?.statement)
+        if ((file?.statement?.relation_version ?? 0) !== snapshot.relation_version)
             throw failure('unavailable', 'NS relation metadata does not match agent.md', true);
         if (snapshot.lock === 'locked' && (!file?.statement || file.statement.relation_version !== snapshot.relation_version || snapshot.owner_aid !== undefined && snapshot.owner_aid !== file.statement.owner_aid))
             throw failure('unavailable', 'NS lock and current signed agent.md differ', true);
         return { ...snapshot, file, owner_aid: snapshot.lock === 'locked' ? file.statement.owner_aid : null };
     }
     isBase(task, ns) {
-        return ns.relation_version === task.base_relation_version && (task.operation === 'bind' ? ns.lock === 'unlocked' : ns.lock === 'locked' && ns.owner_aid === task.owner_aid);
+        const base = task.base_agent_md;
+        return ns.relation_version === task.base_relation_version && (task.operation === 'bind' ? ns.lock === 'unlocked' : ns.lock === 'locked' && ns.owner_aid === task.owner_aid) && (!base || base.exists === ns.exists && (base.statement ? this.sameStatement(base.statement, ns.file?.statement) : !ns.file?.statement && base.raw === ns.content && base.etag === ns.etag));
+    }
+    async captureBase(task, ns) {
+        if (!task.base_agent_md)
+            task.base_agent_md = { exists: ns.exists, raw: ns.content, sha256: await ownershipSha256(ns.content), etag: ns.etag, statement: ns.file?.statement ?? null };
+        if (!task.base_owner_md) {
+            const prior = ns.file?.statement ? await this.deps.files.readOwner(ns.file.statement.owner_aid, task.sub_aid) : null;
+            task.base_owner_md = prior ? { exists: prior.exists, raw: prior.content, sha256: prior.sha256 } : { exists: false, raw: '', sha256: '' };
+        }
+    }
+    async validateLegacyBind(task) {
+        const aid = this.deps.currentAid();
+        if (task.base_agent_md != null || task.base_owner_md != null || task.schema_version !== 1 || !this.ongoing(task) || task.operation !== 'bind' || task.initiator_aid !== task.sub_aid || task.base_relation_version !== 0 || task.target_relation_version !== 1 || task.new_owner_aid !== undefined || !task.request_validated || task.approvals[aid] !== task.local_decision || Object.values(task.approvals).includes('reject') || !Number.isSafeInteger(task.created_at) || task.created_at <= 0 || task.release_cleanup !== undefined || task.verified_consensus !== undefined || task.cleanup_pending || task.cleanup_done || task.authorization_sha256 !== undefined || task.expires_at !== undefined || task.legacy_recovery !== undefined)
+            throw failure('persistence_unavailable', 'legacy bind context cannot be recovered');
+        parseOwnershipMessage(this.message(task, 'bind.request'));
+        if (JSON.stringify(task.local_roles) !== JSON.stringify(ownershipLocalRoles(task, aid)) || !task.local_roles.length || JSON.stringify(Object.keys(task.approvals).sort()) !== JSON.stringify(participants(task).sort()) || task.approvals[task.sub_aid] !== 'accept' || Object.values(task.approvals).some((value) => !['pending', 'accept'].includes(value)))
+            throw failure('persistence_unavailable', 'legacy bind approval is damaged');
+        for (const [key, prepared] of Object.entries(task.files)) {
+            const condition = prepared.condition, published = prepared.published_revision;
+            if (key !== 'owner' || !task.local_roles.includes('owner') || task.local_decision !== 'accept' || typeof prepared.raw !== 'string' || prepared.sha256 !== await ownershipSha256(prepared.raw) || !condition || Object.keys(condition).length !== 1 || typeof condition.expected_revision !== 'string' || !condition.expected_revision || published !== undefined && (typeof published !== 'string' || !published) || prepared.expires_at !== undefined || prepared.cleaned)
+                throw failure('persistence_unavailable', 'legacy bind file cannot be reused');
+            const file = parseOwnershipFile(prepared.raw, 'owner', { expectedSubAid: task.sub_aid, expectedOwnerAid: task.owner_aid });
+            if (file.action !== 'declare' || file.statement?.relation_version !== 1)
+                throw failure('persistence_unavailable', 'legacy owner declaration differs');
+        }
+        const validate = (payload, from, to) => {
+            if (!payload || ['bind.reject', 'operation.stopped'].includes(payload.action))
+                throw failure('persistence_unavailable', 'legacy bind contains terminal or mixed controls');
+            const message = parseOwnershipMessage({ ...payload });
+            validateOwnershipMessage(message, { authenticated_from_aid: from, local_aid: to, task });
+        };
+        for (const key of task.received) {
+            if (typeof key !== 'string' || key.split('|').length !== 2)
+                throw failure('persistence_unavailable', 'legacy received journal is damaged');
+            const [from, action] = key.split('|'), payload = this.message(task, action);
+            validate(payload, from, aid);
+        }
+        for (const item of task.inbox) {
+            validate(item.payload, item.from_aid, aid);
+            if (!task.received.includes(`${item.from_aid}|${item.payload.action}`))
+                throw failure('persistence_unavailable', 'legacy inbox is damaged');
+        }
+        for (const item of task.outbox) {
+            validate(item.payload, aid, item.to_aid);
+            if (item.key !== `${item.to_aid}|${item.payload.action}` || !/^m-[0-9a-f]{32}$/.test(item.message_id) || item.payload.action !== 'bind.request' && task.local_decision !== 'accept')
+                throw failure('persistence_unavailable', 'legacy outbox is damaged');
+        }
+        for (const key of task.sent) {
+            if (typeof key !== 'string' || key.split('|').length !== 2)
+                throw failure('persistence_unavailable', 'legacy sent journal is damaged');
+            const [to, action] = key.split('|'), payload = this.message(task, action);
+            validate(payload, aid, to);
+        }
+    }
+    async recoverLegacyBind(context) {
+        const original = context.task;
+        await this.validateLegacyBind(original);
+        const before = await this.observe(original.sub_aid);
+        if (before.lock === 'locked' && before.owner_aid === original.owner_aid && before.relation_version === original.target_relation_version)
+            return this.recoverPrior(context);
+        if (before.relation_version !== 0 || before.lock !== 'unlocked' || before.owner_aid || before.file?.statement)
+            throw failure('conflict', 'legacy bind relationship base changed');
+        const owner = await this.deps.files.readOwner(original.owner_aid, original.sub_aid), prepared = original.files.owner;
+        if (prepared && (!owner.exists || owner.content !== prepared.raw || owner.sha256 !== prepared.sha256) || !prepared && original.local_roles.includes('owner') && owner.exists)
+            throw failure('conflict', 'legacy owner original cannot be confirmed');
+        const publishedRevision = prepared?.published_revision;
+        if (publishedRevision !== undefined && owner.revision !== publishedRevision)
+            throw failure(owner.revision ? 'conflict' : 'unavailable', 'legacy published owner revision changed', !owner.revision);
+        if (owner.exists) {
+            const file = await this.deps.files.verify(owner.content, 'owner', original.sub_aid, original.owner_aid);
+            if (file.action !== 'declare' || file.statement?.relation_version !== 1)
+                throw failure('conflict', 'legacy owner declaration changed');
+        }
+        const serialized = JSON.stringify(original);
+        const candidate = prepared ?? (original.local_roles.includes('sub') && owner.exists ? { raw: owner.content, sha256: owner.sha256 } : undefined);
+        const originalOwner = { exists: owner.exists, raw: owner.content, sha256: owner.sha256, ...(prepared && owner.revision ? { revision: owner.revision } : {}) };
+        const task = { ...original, status: 'pending', step: 'compatibility_checkpoint', retryable: true, files: candidate ? { owner: { raw: candidate.raw, sha256: candidate.sha256, condition: {}, original_owner: originalOwner } } : {}, inbox: [], received: [], outbox: [], sent: [], hints: {}, legacy_recovery: { task: JSON.parse(serialized), revision: context.revision, task_sha256: await ownershipSha256(serialized), checkpoint: { observed_at: before.observed_at, owner_md: originalOwner }, owner_confirmed: false } };
+        delete task.code;
+        delete task.reason;
+        delete task.base_agent_md;
+        delete task.base_owner_md;
+        await this.captureBase(task, before);
+        const afterOwner = await this.deps.files.readOwner(task.owner_aid, task.sub_aid), after = await this.observe(task.sub_aid);
+        if (owner.exists !== afterOwner.exists || owner.content !== afterOwner.content || owner.sha256 !== afterOwner.sha256 || before.exists !== after.exists || before.content !== after.content || before.etag !== after.etag || before.relation_version !== after.relation_version || before.lock !== after.lock || before.owner_aid !== after.owner_aid)
+            throw failure('conflict', 'legacy compatibility observations changed');
+        if (task.local_roles.includes('sub'))
+            this.enqueue(task, task.owner_aid, 'bind.request');
+        else if (task.local_decision === 'accept')
+            this.enqueue(task, task.sub_aid, 'bind.accept');
+        context.task = task;
+        await this.save(context);
     }
     isTarget(task, ns) {
-        return ns.relation_version === task.target_relation_version && (task.operation === 'release' ? ns.lock === 'unlocked' : ns.lock === 'locked' && ns.owner_aid === targetOwner(task));
+        return ns.relation_version === (task.operation === 'release' ? task.base_relation_version : task.target_relation_version) && (task.operation === 'release' ? ns.lock === 'unlocked' && !ns.owner_aid : ns.lock === 'locked' && ns.owner_aid === targetOwner(task));
     }
-    fileTask(context) {
-        const task = { ...context.task, files: context.task.files,
-            persist: async () => { context.task.expires_at = task.expires_at; context.task.authorization_sha256 = task.authorization_sha256; await this.save(context); },
-            guard: async () => { context.task.expires_at = task.expires_at; context.task.authorization_sha256 = task.authorization_sha256; await this.save(context); } };
+    async priorView(original) {
+        if (original.base_agent_md != null || original.base_owner_md != null || original.legacy_task || original.legacy_recovery || !original.request_validated || !this.ongoing(original) || Object.values(original.approvals ?? {}).includes('reject'))
+            throw failure('persistence_unavailable', 'legacy task context cannot be recovered');
+        const task = structuredClone(original);
+        for (const [key, prepared] of Object.entries(task.files ?? {})) {
+            if (['agent', 'cleanup'].includes(key))
+                continue;
+            const condition = prepared.condition;
+            if (!prepared.original_owner && (!condition || Object.keys(condition).length !== 1 || typeof condition.expected_revision !== 'string' || !condition.expected_revision))
+                throw failure('persistence_unavailable', 'legacy owner condition is invalid');
+            prepared.condition = {};
+            prepared.original_owner ??= { exists: false, raw: '', sha256: '' };
+        }
+        await this.record({ revision: 1, record: task }, true);
+        return task;
+    }
+    async recoverPrior(context) {
+        const original = structuredClone(context.task), task = await this.priorView(original);
+        const ns = await this.observe(task.sub_aid);
+        const base = this.isBase(task, ns), released = task.operation === 'release' && this.isTarget(task, ns);
+        const committed = task.operation !== 'release' && this.isTarget(task, ns);
+        if (!base && !released && !committed)
+            throw failure('conflict', 'legacy relationship no longer matches this task');
+        if (!committed)
+            await this.captureBase(task, ns);
+        for (const [key, prepared] of Object.entries(task.files)) {
+            const agent = ['agent', 'cleanup'].includes(key), ownerAid = ['agent', 'owner'].includes(key) ? targetOwner(task) : task.owner_aid;
+            await this.deps.files.verify(prepared.raw, agent ? 'agent' : 'owner', task.sub_aid, agent && key === 'cleanup' ? undefined : ownerAid);
+            if (agent)
+                continue;
+            const current = await this.deps.files.readOwner(ownerAid, task.sub_aid), source = original.files[key];
+            const revision = source.condition.expected_revision;
+            if (revision && (current.content === prepared.raw && source.published_revision !== undefined || !committed && current.content !== prepared.raw)) {
+                if (!current.revision)
+                    throw failure('unavailable', 'legacy owner original revision is unavailable');
+                if (current.revision !== (current.content === prepared.raw ? source.published_revision : revision))
+                    throw failure('conflict', 'legacy owner original revision changed');
+            }
+            const statement = current.exists ? parseOwnershipFile(current.content, 'owner', { expectedSubAid: task.sub_aid }).statement : undefined;
+            if (current.content !== prepared.raw && (source.published_revision !== undefined || current.exists && (key === 'owner' || !this.sameStatement(statement, parseOwnershipFile(prepared.raw, 'owner', { expectedSubAid: task.sub_aid }).statement))) && !committed)
+                throw failure('conflict', 'legacy signed owner file was replaced');
+            prepared.original_owner = { exists: current.exists, raw: current.content, sha256: current.sha256, ...(revision && current.revision ? { revision: current.revision } : {}) };
+        }
+        task.legacy_task = { task: original, revision: context.revision, task_sha256: await ownershipSha256(JSON.stringify(original)), checkpoint: { agent_md: task.base_agent_md ?? null, owner_md: task.base_owner_md ?? null } };
+        context.task = task;
+        if (committed) {
+            if (!await this.complete(context, ns))
+                throw failure('conflict', 'legacy committed target lacks matching local signed evidence');
+        }
+        else
+            await this.save(context);
+    }
+    fileTask(context, expectedStatement) {
+        const task = { ...context.task, files: context.task.files, expected_agent_statement: expectedStatement,
+            persist: async () => { context.task.expires_at = task.expires_at; context.task.authorization_sha256 = task.authorization_sha256; context.task.base_agent_md = task.base_agent_md; context.task.base_owner_md = task.base_owner_md; await this.save(context); },
+            guard: async () => { context.task.expires_at = task.expires_at; context.task.authorization_sha256 = task.authorization_sha256; context.task.base_agent_md = task.base_agent_md; context.task.base_owner_md = task.base_owner_md; await this.save(context); } };
         return task;
     }
     async start(operation, subAid, ownerAid, newOwnerAid, requestedId, guard) {
@@ -502,7 +750,11 @@ export class OwnershipWorkflow {
             }
         }
         const intent = { initiator_aid: aid, operation, sub_aid: subAid, owner_aid: ownerAid, new_owner_aid: newOwnerAid };
-        for (const pending of (await this.records(aid)).filter((task) => task.sub_aid === subAid && this.ongoing(task))) {
+        if (operation === 'bind' && requestedId === undefined)
+            await this.prepareBind(subAid, intent, guard);
+        for (const pending of (await this.records(aid, subAid, undefined, true)).filter((task) => task.sub_aid === subAid && this.ongoing(task))) {
+            if (!pending.base_agent_md && pending.request_validated && !this.sameIntent(pending, intent))
+                throw failure('conflict', 'another local legacy operation for this sub is pending');
             if (this.sameIntent(pending, intent)) {
                 const result = await this.advance(subAid, pending.operation_id, undefined, events, undefined, guard);
                 if (result.status !== 'stopped' || result.code !== 'conflict' || !/relation version or target was replaced/.test(result.reason ?? ''))
@@ -519,12 +771,12 @@ export class OwnershipWorkflow {
         }
         const ns = await this.observe(subAid);
         if (operation === 'bind') {
-            if (!ns.exists)
-                throw failure('unavailable', 'initial agent.md is not published', true);
             if (ns.lock === 'locked')
                 throw failure('owner_locked', 'the sub AID has a current owner lock');
-            if (ns.file?.frontmatter.type === 'human')
+            if ((ns.exists ? ns.file?.frontmatter.type : subAid === aid ? this.deps.currentAidType?.() : undefined) === 'human')
                 throw failure('invalid', 'human cannot declare an owner');
+            if (ns.file?.statement?.owner_aid === ownerAid)
+                throw failure('conflict', 'current owner release requires sub cleanup before binding again');
         }
         else {
             if (aid !== ownerAid || ns.lock !== 'locked' || ns.owner_aid !== aid)
@@ -533,10 +785,11 @@ export class OwnershipWorkflow {
             if (consensus.status !== 'consensus' || consensus.owner_aid !== aid || consensus.relation_version !== ns.relation_version)
                 throw failure(consensus.status === 'invalid' ? 'invalid' : 'unavailable', 'the current owner relation could not be verified', consensus.status !== 'invalid');
         }
-        ownershipInteger(ns.relation_version + 1, 'target_relation_version');
+        const targetVersion = ownershipInteger(ns.relation_version + (operation === 'release' ? 0 : 1), 'target_relation_version');
         const operationId = requestedId ?? crypto.randomUUID();
-        const payload = { type: OWNERSHIP_SDK_MESSAGE_TYPE, operation_id: operationId, operation, action: operation === 'bind' ? 'bind.request' : operation === 'transfer' ? 'transfer.request' : 'relation.confirmed', sub_aid: subAid, owner_aid: ownerAid, ...(newOwnerAid ? { new_owner_aid: newOwnerAid } : {}), base_relation_version: ns.relation_version, target_relation_version: ns.relation_version + 1 };
+        const payload = { type: OWNERSHIP_SDK_MESSAGE_TYPE, operation_id: operationId, operation, action: operation === 'bind' ? 'bind.request' : operation === 'transfer' ? 'transfer.request' : 'relation.confirmed', sub_aid: subAid, owner_aid: ownerAid, ...(newOwnerAid ? { new_owner_aid: newOwnerAid } : {}), base_relation_version: ns.relation_version, target_relation_version: targetVersion };
         const task = this.create(payload, aid, 'accept');
+        await this.captureBase(task, ns);
         if (!task.local_roles.length)
             throw failure('forbidden', 'the local AID is not an ownership participant');
         if (aid !== this.deps.currentAid())
@@ -558,6 +811,128 @@ export class OwnershipWorkflow {
     async releaseSubaid(subAid) { return await this.start('release', subAid, this.deps.currentAid()); }
     async transferSubaid(subAid, newOwnerAid) { return await this.start('transfer', subAid, this.deps.currentAid(), newOwnerAid); }
     async startRegistrationIntent(ownerAid, operationId, guard) { return await this.start('bind', this.deps.currentAid(), ownerAid, undefined, operationId, guard); }
+    async resetTask(operationId, expected) {
+        const aid = this.deps.currentAid(), store = this.deps.store;
+        if (typeof store.resetOwnershipTask !== 'function')
+            throw storageFailure('ownership task reset storage is unavailable');
+        let result;
+        try {
+            result = await store.resetOwnershipTask(aid, operationId, expected);
+        }
+        catch (error) {
+            if (error instanceof StateError)
+                throw error;
+            throw storageFailure(`ownership task reset failed: ${String(error)}`);
+        }
+        if (aid !== this.deps.currentAid())
+            throw failure('forbidden', 'ownership current identity changed');
+        return result;
+    }
+    async resetOwnershipTask() {
+        const aid = this.deps.currentAid(), reset = new Set(), skipped = new Set();
+        if (typeof this.deps.store.resetOwnershipTask !== 'function')
+            throw storageFailure('ownership task reset storage is unavailable');
+        const list = async () => {
+            try {
+                return await this.storage().listOwnershipTasks(aid, true);
+            }
+            catch (error) {
+                throw storageFailure(`ownership task list failed: ${String(error)}`);
+            }
+        };
+        for (const original of await list()) {
+            let snapshot = original;
+            for (;;) {
+                if (aid !== this.deps.currentAid())
+                    throw failure('forbidden', 'ownership current identity changed');
+                if (snapshot.record.reset === true && snapshot.revision > 0)
+                    break;
+                const operationId = snapshot.record.operation_id;
+                if (typeof operationId !== 'string')
+                    throw storageFailure('ownership task identity cannot be determined for reset');
+                if (!OWNERSHIP_UUID_V4_RE.test(operationId)) {
+                    skipped.add(operationId);
+                    break;
+                }
+                const record = rawTaskRecord(snapshot);
+                if (record && (Object.hasOwn(record, 'reset') || Object.hasOwn(record, 'reset_archive'))) {
+                    skipped.add(operationId);
+                    break;
+                }
+                let initiator;
+                try {
+                    initiator = ownershipAid(record?.initiator_aid, 'initiator_aid');
+                }
+                catch { }
+                const status = record?.status;
+                if (!initiator || typeof status !== 'string' || !['pending', 'completed', 'rejected', 'stopped', 'error'].includes(status)) {
+                    skipped.add(operationId);
+                    break;
+                }
+                if (initiator !== aid || status !== 'pending' && status !== 'error')
+                    break;
+                try {
+                    await this.resetTask(operationId, snapshot);
+                    reset.add(operationId);
+                    break;
+                }
+                catch (error) {
+                    if (!error?.ownershipResetConflict)
+                        throw error;
+                    const current = (await list()).find((row) => row.record.operation_id === operationId);
+                    if (!current)
+                        throw storageFailure('ownership task disappeared during reset');
+                    snapshot = current;
+                }
+            }
+        }
+        return { reset_operation_ids: [...reset].sort(), skipped_operation_ids: [...skipped].sort() };
+    }
+    async prepareBind(subAid, intent, guard) {
+        const aid = this.deps.currentAid();
+        let snapshots;
+        try {
+            snapshots = await this.storage().listOwnershipTasks(aid, true);
+        }
+        catch (error) {
+            throw storageFailure(`ownership task list failed: ${String(error)}`);
+        }
+        for (const snapshot of snapshots) {
+            guard?.();
+            if (aid !== this.deps.currentAid())
+                throw failure('forbidden', 'ownership current identity changed');
+            if (snapshot.record.reset === true && snapshot.revision > 0)
+                continue;
+            if (typeof snapshot.record.sub_aid !== 'string')
+                throw storageFailure('ownership task subject cannot be determined for automatic reset');
+            if (snapshot.record.sub_aid !== subAid)
+                continue;
+            const raw = rawTaskRecord(snapshot);
+            if (raw && (Object.hasOwn(raw, 'reset') || Object.hasOwn(raw, 'reset_archive')))
+                throw storageFailure('ownership reset persistence is damaged');
+            let task;
+            try {
+                task = await this.record(snapshot);
+            }
+            catch (error) {
+                if (!error?.ownershipTaskDamage)
+                    throw error;
+                await this.resetTask(String(snapshot.record.operation_id), snapshot);
+                continue;
+            }
+            if (!task.base_agent_md && task.request_validated && this.sameIntent(task, intent) && (this.ongoing(task) || task.status === 'stopped' && task.code === 'unsupported_protocol')) {
+                try {
+                    if (task.operation === 'bind' && task.initiator_aid === task.sub_aid && task.base_relation_version === 0 && Object.keys(task.files ?? {}).every((key) => key === 'owner'))
+                        await this.validateLegacyBind(task);
+                    else
+                        await this.priorView(task);
+                }
+                catch {
+                    await this.resetTask(task.operation_id, snapshot);
+                }
+            }
+        }
+    }
     async checkOwnershipConsensus(subAid = this.deps.currentAid()) { return await this.deps.files.checkConsensus(subAid); }
     async decide(operationId, decision, reason) {
         const saved = await this.load(operationId);
@@ -623,6 +998,8 @@ export class OwnershipWorkflow {
             throw error;
         }
         const snapshot = await this.load(message.operation_id);
+        if (snapshot?.record.reset === true && snapshot.revision > 0)
+            return true;
         const prior = snapshot ? await this.record(snapshot) : undefined;
         if (!prior && !['bind.request', 'transfer.request'].includes(message.action) && !(message.operation === 'release' && message.action === 'relation.confirmed'))
             return true;
@@ -662,34 +1039,54 @@ export class OwnershipWorkflow {
         return true;
     }
     async confirmSubCleaned(task) {
-        const began = this.now(), before = await this.deps.files.readAgent(task.sub_aid), after = await this.deps.files.readAgent(task.sub_aid);
-        if (this.now() - began > 30 || before.exists !== after.exists || before.etag !== after.etag || before.relation_version !== after.relation_version || before.lock !== after.lock || before.owner_aid !== after.owner_aid || await ownershipSha256(before.content) !== await ownershipSha256(after.content))
-            throw failure('unavailable', 'NS changed during sub cleanup verification', true);
-        if (!before.exists || before.relation_version !== task.target_relation_version || before.lock !== 'unlocked' || before.owner_aid || !before.etag)
+        const began = this.now(), before = await this.deps.files.readAgent(task.sub_aid);
+        if (!before.exists || before.relation_version !== 0 || before.lock !== 'unlocked' || before.owner_aid || !before.etag)
             return false;
         const file = parseOwnershipFile(before.content, 'agent', { expectedSubAid: task.sub_aid });
-        return !Object.hasOwn(file.frontmatter, 'owner') && !Object.hasOwn(file.frontmatter, 'ownership');
+        if (Object.hasOwn(file.frontmatter, 'owner') || Object.hasOwn(file.frontmatter, 'ownership'))
+            return false;
+        if (!task.base_agent_md?.statement || task.base_agent_md.statement.owner_aid !== task.owner_aid || task.base_agent_md.statement.sub_aid !== task.sub_aid || task.base_agent_md.statement.relation_version !== task.base_relation_version)
+            return false;
+        let ownerHash = '';
+        if (task.local_roles.includes('owner') && task.files.release) {
+            const original = task.files.release, object = await this.deps.files.readOwner(task.owner_aid, task.sub_aid);
+            if (object.exists && object.content === original.raw && object.sha256 === original.sha256) {
+                const file = await this.deps.files.verify(object.content, 'owner', task.sub_aid, task.owner_aid);
+                if (file.action === 'release' && file.statement && ['version', 'owner_aid', 'sub_aid', 'relation_version'].every((key) => file.statement[key] === task.base_agent_md.statement[key]))
+                    ownerHash = object.sha256;
+            }
+        }
+        const confirmed = Boolean(await this.cleanupEvidence(task, { agent_md_etag: before.etag, agent_md_sha256: await ownershipSha256(before.content), owner_md_sha256: ownerHash }, before.content));
+        const after = await this.deps.files.readAgent(task.sub_aid);
+        if (this.now() - began > 30 || before.exists !== after.exists || before.etag !== after.etag || before.relation_version !== after.relation_version || before.lock !== after.lock || before.owner_aid !== after.owner_aid || before.content !== after.content)
+            throw failure('unavailable', 'NS changed during sub cleanup verification', true);
+        return confirmed;
     }
     async resume(guard) {
         guard?.();
         let snapshots;
         try {
-            snapshots = await this.storage().listOwnershipTasks(this.deps.currentAid());
+            snapshots = await this.storage().listOwnershipTasks(this.deps.currentAid(), true);
         }
         catch (error) {
             throw failure('persistence_unavailable', `ownership task list failed: ${String(error)}`);
         }
         for (const snapshot of snapshots) {
             guard?.();
-            const task = await this.record(snapshot);
-            if (['rejected', 'stopped'].includes(task.status) && !task.outbox.length && !task.inbox.length || task.status === 'completed' && !task.cleanup_pending && !task.outbox.length && !task.inbox.length && !(['bind', 'transfer'].includes(task.operation) && task.local_roles.includes('sub') && task.local_decision === 'accept' && !task.release_cleanup?.cleaned))
+            if (snapshot.record.reset === true && snapshot.revision > 0)
                 continue;
             try {
+                const task = await this.record(snapshot);
+                if (!task.base_agent_md && task.request_validated && task.status === 'completed')
+                    continue;
+                if (['rejected', 'stopped'].includes(task.status) && !task.outbox.length && !task.inbox.length || task.status === 'completed' && !task.cleanup_pending && !task.outbox.length && !task.inbox.length && !(['bind', 'transfer'].includes(task.operation) && task.local_roles.includes('sub') && task.local_decision === 'accept' && !task.release_cleanup?.cleaned))
+                    continue;
                 await this.execute(task.sub_aid, task.operation_id, undefined, undefined, guard);
             }
             catch (error) {
+                guard?.();
                 if (ownershipErrorCode(error) !== 'conflict')
-                    throw error;
+                    await this.deps.emit('ownership.error', { operation_id: snapshot.record.operation_id, sub_aid: snapshot.record.sub_aid, code: ownershipErrorCode(error), reason: String(error), retryable: false });
             }
         }
     }
@@ -703,6 +1100,25 @@ export class OwnershipWorkflow {
             }
             const entry = task.inbox[0];
             const ns = await this.observe(task.sub_aid);
+            if (!task.base_agent_md && !task.request_validated && task.local_decision === 'pending' && !Object.keys(task.files).length) {
+                if (this.isBase(task, ns) || task.operation === 'release' && ns.relation_version === task.base_relation_version && ns.file?.statement?.owner_aid === task.owner_aid)
+                    await this.captureBase(task, ns);
+                else if (task.operation === 'release' && ns.relation_version === 0 && !ns.file?.statement && task.local_roles.includes('sub')) {
+                    for (const candidate of await this.records(context.aid, task.sub_aid)) {
+                        const original = candidate.files.agent, cleanup = candidate.release_cleanup?.files.cleanup;
+                        if (!['bind', 'transfer'].includes(candidate.operation) || candidate.local_decision !== 'accept' || !candidate.local_roles.includes('sub') || targetOwner(candidate) !== task.owner_aid || candidate.target_relation_version !== task.base_relation_version || !original || !cleanup || cleanup.raw !== ns.content || cleanup.sha256 !== await ownershipSha256(ns.content) || cleanup.published_etag !== undefined && cleanup.published_etag !== ns.etag)
+                            continue;
+                        const statement = parseOwnershipFile(original.raw, 'agent', { expectedSubAid: task.sub_aid }).statement;
+                        if (!statement || !cleanup.condition?.if_match)
+                            continue;
+                        task.base_agent_md = { exists: true, raw: original.raw, sha256: original.sha256, etag: cleanup.condition.if_match, statement };
+                        task.cleanup_authorization_operation_id = candidate.operation_id;
+                        break;
+                    }
+                }
+                if (task.base_agent_md)
+                    await this.save(context);
+            }
             try {
                 validateOwnershipMessage(entry.payload, { authenticated_from_aid: entry.from_aid, local_aid: context.aid, task, ns });
             }
@@ -719,6 +1135,11 @@ export class OwnershipWorkflow {
                 }
                 else if (['bind.accept', 'transfer.accept', 'bind.reject', 'transfer.reject'].includes(action)) {
                     const decision = action.endsWith('.accept') ? 'accept' : 'reject';
+                    if (decision === 'reject' && await this.complete(context, ns)) {
+                        task.inbox.shift();
+                        await this.save(context);
+                        continue;
+                    }
                     if (!task.approvals[entry.from_aid] || task.approvals[entry.from_aid] === 'pending') {
                         task.approvals[entry.from_aid] = decision;
                         if (decision === 'reject') {
@@ -744,6 +1165,20 @@ export class OwnershipWorkflow {
                     }
                 }
                 else {
+                    if (action === 'owner.ready' && task.legacy_recovery) {
+                        const owner = await this.deps.files.readOwner(task.owner_aid, task.sub_aid);
+                        const pinned = task.files.owner;
+                        if (pinned && (!owner.exists || owner.content !== pinned.raw || owner.sha256 !== pinned.sha256))
+                            throw failure('conflict', 'legacy owner candidate was replaced');
+                        if (!owner.exists)
+                            throw failure('unavailable', 'legacy owner confirmation is unavailable', true);
+                        const file = await this.deps.files.verify(owner.content, 'owner', task.sub_aid, task.owner_aid);
+                        if (file.action !== 'declare' || file.statement?.relation_version !== task.target_relation_version)
+                            throw failure('conflict', 'legacy owner confirmation differs');
+                        if (!pinned)
+                            task.files.owner = { raw: owner.content, sha256: owner.sha256, condition: {}, original_owner: { exists: true, raw: owner.content, sha256: owner.sha256 } };
+                        task.legacy_recovery.owner_confirmed = true;
+                    }
                     if (action === 'transfer.ready' && this.isBase(task, ns)) {
                         const authorization = await this.deps.files.verifyTransfer(this.fileTask(context));
                         task.expires_at = authorization.transfer.expires_at;
@@ -753,7 +1188,7 @@ export class OwnershipWorkflow {
             }
             else if (action === 'sub.cleaned') {
                 const file = ns.file;
-                if (ns.relation_version === task.target_relation_version && ns.lock === 'unlocked' && !ns.owner_aid && file && !file.statement && !Object.hasOwn(file.frontmatter, 'owner') && !Object.hasOwn(file.frontmatter, 'ownership'))
+                if (ns.relation_version === 0 && ns.lock === 'unlocked' && !ns.owner_aid && file && !file.statement && !Object.hasOwn(file.frontmatter, 'owner') && !Object.hasOwn(file.frontmatter, 'ownership'))
                     task.hints[action] = true;
             }
             task.inbox.shift();
@@ -763,10 +1198,29 @@ export class OwnershipWorkflow {
     async flush(context, ns) {
         const task = context.task;
         for (const item of [...task.outbox]) {
+            ns = await this.observe(task.sub_aid);
             const action = item.payload.action;
             const notification = ['relation.confirmed', 'sub.cleaned'].includes(action);
             const terminal = ['bind.reject', 'transfer.reject', 'operation.stopped'].includes(action);
-            if (!terminal && (notification ? !this.isTarget(task, ns) : !this.isBase(task, ns) || task.status === 'completed' || task.status === 'rejected' || task.status === 'stopped')) {
+            const cleaned = action === 'sub.cleaned' && task.status === 'completed' && await this.confirmSubCleaned(task);
+            let base = this.isBase(task, ns);
+            if (!notification && base && task.request_validated && task.base_agent_md?.statement && task.base_owner_md) {
+                const object = await this.deps.files.readOwner(task.base_agent_md.statement.owner_aid, task.sub_aid), original = task.base_owner_md;
+                const prepared = task.files[task.operation === 'transfer' ? 'transfer' : task.operation === 'release' ? 'release' : 'owner'];
+                base = object.exists === original.exists && object.content === original.raw && object.sha256 === original.sha256 || Boolean(prepared && object.exists && object.content === prepared.raw && object.sha256 === prepared.sha256);
+                if (!base && task.operation === 'transfer' && !task.local_roles.includes('owner') && task.local_decision === 'accept') {
+                    try {
+                        await this.deps.files.verifyTransfer(this.fileTask(context));
+                        base = true;
+                    }
+                    catch (error) {
+                        if (ownershipErrorCode(error) !== 'conflict')
+                            throw error;
+                    }
+                }
+            }
+            const target = notification && this.isTarget(task, ns) && (task.operation === 'release' ? this.sameStatement(task.base_agent_md?.statement ?? undefined, ns.file?.statement) : !task.files.agent || this.sameStatement(parseOwnershipFile(task.files.agent.raw, 'agent', { expectedSubAid: task.sub_aid }).statement, ns.file?.statement));
+            if (notification ? !target && !cleaned : !base || !terminal && (task.status === 'completed' || task.status === 'rejected' || task.status === 'stopped')) {
                 task.outbox = task.outbox.filter((row) => row.key !== item.key);
                 await this.save(context);
                 continue;
@@ -789,19 +1243,43 @@ export class OwnershipWorkflow {
     }
     async complete(context, ns) {
         const task = context.task;
-        if (!this.isTarget(task, ns))
+        const began = Date.now(), cleaned = task.operation === 'release' && ns.exists && ns.relation_version === 0 && ns.lock === 'unlocked' && !ns.file?.statement;
+        if (!this.isTarget(task, ns) && !cleaned)
             return false;
         let consensus;
         if (task.operation === 'release') {
             consensus = await this.deps.files.checkConsensus(task.sub_aid);
-            if (consensus.status !== 'released' || consensus.relation_version !== task.target_relation_version || consensus.lock !== ns.lock || consensus.owner_aid !== ns.owner_aid || consensus.agent_md_etag !== ns.etag)
+            if ((cleaned ? consensus.status !== 'unbound' || consensus.relation_version !== 0 : consensus.status !== 'released' || consensus.relation_version !== task.base_relation_version) || consensus.lock !== ns.lock || consensus.owner_aid !== ns.owner_aid || consensus.agent_md_etag !== ns.etag || consensus.agent_md_sha256 !== await ownershipSha256(ns.content))
                 throw failure(consensus.status === 'invalid' ? 'invalid' : 'unavailable', 'ownership release could not be freshly confirmed', consensus.status !== 'invalid');
+            if (!cleaned && task.files.release && consensus.owner_md_sha256) {
+                const source = task.files.release;
+                if (source.sha256 !== consensus.owner_md_sha256)
+                    throw failure('conflict', 'current release material does not belong to this task');
+            }
+            if (cleaned) {
+                const source = task.files.release;
+                if (task.local_roles.includes('owner') && source) {
+                    const object = await this.deps.files.readOwner(task.owner_aid, task.sub_aid);
+                    if (object.exists && object.content === source.raw && object.sha256 === source.sha256) {
+                        await this.deps.files.verify(object.content, 'owner', task.sub_aid, task.owner_aid);
+                        consensus.owner_md_sha256 = object.sha256;
+                    }
+                }
+                const authorization = await this.cleanupEvidence(task, consensus, ns.content);
+                if (!authorization)
+                    throw failure('conflict', 'no local cleanup original can confirm this release task');
+                const after = await this.observe(task.sub_aid);
+                if (Date.now() - began > 30_000 || after.etag !== ns.etag || after.content !== ns.content || !after.exists || after.relation_version !== 0 || after.lock !== 'unlocked' || after.owner_aid)
+                    throw failure('unavailable', 'NS changed during cleanup confirmation', true);
+                if (authorization !== task.operation_id)
+                    task.cleanup_authorization_operation_id = authorization;
+            }
             const prior = ns.file?.statement;
-            if (prior && (prior.owner_aid !== task.owner_aid || prior.relation_version !== task.base_relation_version))
+            if (prior && (prior.owner_aid !== task.owner_aid || prior.relation_version !== task.base_relation_version || !this.sameStatement(prior, task.base_agent_md?.statement ?? undefined)))
                 throw failure('conflict', 'ownership released document does not match this generation');
             if (task.local_roles.includes('owner') && !task.files.release)
                 throw failure('conflict', 'ownership completion lacks this task original owner file');
-            if (prior && task.local_roles.includes('sub') && !task.local_roles.includes('owner') && !await this.authorizeCleanup(context)) {
+            if (prior && task.local_roles.includes('sub') && !task.local_roles.includes('owner') && !await this.authorizeCleanup(context, prior)) {
                 task.status = 'pending';
                 task.step = 'cleanup_action_required';
                 task.cleanup_pending = true;
@@ -821,16 +1299,14 @@ export class OwnershipWorkflow {
                 throw failure(consensus.status === 'invalid' ? 'invalid' : 'unavailable', 'ownership target materials could not be verified', consensus.status !== 'invalid');
             if (task.local_roles.includes('sub') && (!task.files.agent || task.files.agent.sha256 !== consensus.agent_md_sha256))
                 throw failure('conflict', 'NS accepted agent.md does not match this task original bytes');
-            if (task.local_roles.includes(task.operation === 'transfer' ? 'new_owner' : 'owner') && task.files.owner?.sha256 !== consensus.owner_md_sha256)
+            if ((task.local_roles.includes(task.operation === 'transfer' ? 'new_owner' : 'owner') || task.legacy_recovery && task.local_roles.includes('sub')) && task.files.owner?.sha256 !== consensus.owner_md_sha256)
                 throw failure('conflict', 'Storage owner.md does not match this task original bytes');
             if (task.local_roles.includes('sub') && task.files.agent.published_etag !== undefined && task.files.agent.published_etag !== consensus.agent_md_etag && task.verified_relation_version === undefined)
                 throw failure('conflict', 'NS accepted agent.md revision changed');
-            if (task.local_roles.includes(task.operation === 'transfer' ? 'new_owner' : 'owner') && task.files.owner.published_revision !== undefined && task.files.owner.published_revision !== consensus.owner_md_revision && task.verified_relation_version === undefined)
-                throw failure('conflict', 'Storage owner.md revision changed');
         }
         task.status = 'completed';
         task.step = task.operation === 'release' ? 'released' : 'confirmed';
-        task.verified_relation_version = consensus.relation_version;
+        task.verified_relation_version = task.target_relation_version;
         task.verified_consensus = { ...consensus, protocol: '2.1' };
         delete task.code;
         delete task.reason;
@@ -850,23 +1326,39 @@ export class OwnershipWorkflow {
             await this.save(context);
         return true;
     }
-    async authorizeCleanup(context) {
+    async cleanupEvidence(task, evidence, raw) {
+        const release = task.files.release;
+        if (task.local_roles.includes('owner') && release && release.sha256 === evidence.owner_md_sha256 && release.sha256 === await ownershipSha256(release.raw))
+            return task.operation_id;
+        if (!task.local_roles.includes('sub'))
+            return undefined;
+        const matches = async (prepared) => Boolean(prepared && prepared.sha256 === evidence.agent_md_sha256 && prepared.sha256 === await ownershipSha256(prepared.raw) && (raw === undefined || prepared.raw === raw) && (prepared.published_etag === undefined || prepared.published_etag === evidence.agent_md_etag));
+        if (await matches(task.files.cleanup))
+            return task.operation_id;
+        for (const candidate of await this.records(this.deps.currentAid(), task.sub_aid, ['bind', 'transfer'])) {
+            if (!['bind', 'transfer'].includes(candidate.operation))
+                continue;
+            if (task.cleanup_authorization_operation_id && candidate.operation_id !== task.cleanup_authorization_operation_id || candidate.local_decision !== 'accept' || !candidate.local_roles.includes('sub') || candidate.sub_aid !== task.sub_aid || targetOwner(candidate) !== task.owner_aid || candidate.target_relation_version !== task.base_relation_version || !await matches(candidate.release_cleanup?.files.cleanup))
+                continue;
+            const statement = candidate.files.agent && parseOwnershipFile(candidate.files.agent.raw, 'agent', { expectedSubAid: task.sub_aid }).statement;
+            if (statement?.owner_aid === task.owner_aid && statement.sub_aid === task.sub_aid && statement.relation_version === task.base_relation_version && this.sameStatement(statement, task.base_agent_md?.statement ?? undefined))
+                return candidate.operation_id;
+        }
+        return undefined;
+    }
+    sameStatement(left, right) {
+        return Boolean(left && right && ['version', 'declaration_id', 'owner_aid', 'sub_aid', 'relation_version', 'declared_at'].every((key) => left[key] === right[key]));
+    }
+    async authorizeCleanup(context, statement) {
         const task = context.task;
-        const matches = (record) => ['bind', 'transfer'].includes(record.operation) && record.sub_aid === task.sub_aid && record.target_relation_version === task.base_relation_version && record.local_decision === 'accept' && record.local_roles.includes('sub') && targetOwner(record) === task.owner_aid;
+        const matches = (record) => ['bind', 'transfer'].includes(record.operation) && record.sub_aid === task.sub_aid && record.target_relation_version === task.base_relation_version && record.local_decision === 'accept' && record.local_roles.includes('sub') && targetOwner(record) === task.owner_aid && Boolean(record.files.agent && this.sameStatement(parseOwnershipFile(record.files.agent.raw, 'agent', { expectedSubAid: task.sub_aid }).statement, statement));
         if (task.cleanup_authorization_operation_id) {
             const saved = await this.load(task.cleanup_authorization_operation_id);
             if (!saved || !matches(await this.record(saved)))
                 throw failure('persistence_unavailable', 'ownership cleanup historical authorization is damaged');
             return true;
         }
-        let history;
-        try {
-            history = await this.storage().listOwnershipTasks(context.aid);
-        }
-        catch (error) {
-            throw failure('persistence_unavailable', `ownership cleanup history read failed: ${String(error)}`);
-        }
-        const authorized = (await Promise.all(history.map((row) => this.record(row)))).find(matches);
+        const authorized = (await this.records(context.aid, task.sub_aid, ['bind', 'transfer'])).find(matches);
         if (!authorized)
             return false;
         task.cleanup_authorization_operation_id = authorized.operation_id;
@@ -875,13 +1367,23 @@ export class OwnershipWorkflow {
     }
     async resumeSubCleanup(context, ns) {
         const task = context.task;
-        if (!['bind', 'transfer'].includes(task.operation) || !task.local_roles.includes('sub') || task.local_decision !== 'accept' || ns.lock !== 'unlocked' || ns.relation_version !== task.target_relation_version + 1 || task.release_cleanup?.cleaned)
+        if (!['bind', 'transfer'].includes(task.operation) || !task.local_roles.includes('sub') || task.local_decision !== 'accept' || ns.lock !== 'unlocked' || task.release_cleanup?.cleaned)
+            return;
+        if (ns.relation_version === 0 && !ns.file?.statement) {
+            const prepared = task.release_cleanup?.files.cleanup;
+            if (!prepared || !prepared.condition?.if_match || prepared.raw !== ns.content || prepared.sha256 !== await ownershipSha256(ns.content) || prepared.published_etag !== undefined && prepared.published_etag !== ns.etag)
+                throw failure('conflict', 'historical cleanup original file was not confirmed');
+            task.release_cleanup.cleaned = true;
+            await this.save(context);
+            return;
+        }
+        if (ns.relation_version !== task.target_relation_version)
             return;
         const consensus = await this.deps.files.checkConsensus(task.sub_aid);
         if (consensus.status !== 'released' || consensus.relation_version !== ns.relation_version || consensus.agent_md_etag !== ns.etag || consensus.agent_md_sha256 !== await ownershipSha256(ns.content))
             throw failure(consensus.status === 'invalid' ? 'invalid' : 'unavailable', 'NS changed during historical cleanup observation', consensus.status !== 'invalid');
         const statement = ns.file?.statement;
-        if (statement && (statement.owner_aid !== targetOwner(task) || statement.relation_version !== task.target_relation_version))
+        if (!statement || !task.files.agent || !this.sameStatement(statement, parseOwnershipFile(task.files.agent.raw, 'agent', { expectedSubAid: task.sub_aid }).statement))
             throw failure('conflict', 'historical cleanup fields belong to another relation');
         if (!task.release_cleanup) {
             task.release_cleanup = { files: {}, cleaned: false };
@@ -889,7 +1391,7 @@ export class OwnershipWorkflow {
         }
         if (statement || task.release_cleanup.files.cleanup)
             await this.deps.files.revokeOwneraid({ operation: 'release', sub_aid: task.sub_aid, owner_aid: targetOwner(task),
-                base_relation_version: task.target_relation_version, target_relation_version: ns.relation_version, files: task.release_cleanup.files,
+                base_relation_version: task.target_relation_version, target_relation_version: ns.relation_version, files: task.release_cleanup.files, expected_agent_statement: statement,
                 persist: () => this.save(context), guard: () => this.save(context) });
         task.release_cleanup.cleaned = true;
         await this.save(context);
@@ -899,7 +1401,9 @@ export class OwnershipWorkflow {
         const task = context.task;
         if (!task.cleanup_pending || task.cleanup_done)
             return;
-        if (!this.isTarget(task, ns)) {
+        const releaseOwner = task.operation === 'release' && task.local_roles.includes('owner');
+        const cleaned = task.operation === 'release' && ns.relation_version === 0 && ns.lock === 'unlocked' && !ns.file?.statement;
+        if (!this.isTarget(task, ns) && !cleaned && !releaseOwner) {
             task.cleanup_pending = false;
             task.step = 'cleanup_superseded';
             await this.save(context);
@@ -907,7 +1411,9 @@ export class OwnershipWorkflow {
         }
         if (task.operation === 'release' && task.local_roles.includes('sub')) {
             const prior = ns.file?.statement;
-            if (prior && !await this.authorizeCleanup(context)) {
+            if (prior && !this.sameStatement(prior, task.base_agent_md?.statement ?? undefined))
+                throw failure('conflict', 'ownership cleanup original relation was replaced');
+            if (prior && !await this.authorizeCleanup(context, prior)) {
                 task.step = 'cleanup_action_required';
                 await this.save(context);
                 this.event(context, 'ownership.action_required');
@@ -915,18 +1421,18 @@ export class OwnershipWorkflow {
             }
             if (prior && (prior.owner_aid !== task.owner_aid || prior.relation_version !== task.base_relation_version))
                 throw failure('conflict', 'ownership cleanup current fields differ');
-            if (prior)
-                await this.deps.files.revokeOwneraid(this.fileTask(context));
+            if (prior || task.files.cleanup)
+                await this.deps.files.revokeOwneraid(this.fileTask(context, prior));
             this.enqueue(task, task.owner_aid, 'sub.cleaned');
         }
         if (task.local_roles.includes('owner') && (task.operation === 'release' || task.operation === 'transfer')) {
+            if (releaseOwner && this.isTarget(task, ns) && ns.file?.statement)
+                return;
             const prepared = task.files[task.operation === 'release' ? 'release' : 'transfer'];
-            if (prepared && !prepared.published_revision) {
+            if (prepared) {
                 const object = await this.deps.files.readOwner(task.owner_aid, task.sub_aid);
-                if (object.exists && object.sha256 === prepared.sha256 && object.content === prepared.raw) {
-                    prepared.published_revision = object.revision;
-                    await this.save(context);
-                }
+                if (object.exists && (object.sha256 !== prepared.sha256 || object.content !== prepared.raw))
+                    throw failure('conflict', 'ownership cleanup original owner file has been replaced');
             }
             await this.deps.files.cleanupOwnerFile(this.fileTask(context));
         }
@@ -962,7 +1468,7 @@ export class OwnershipWorkflow {
             delete task.reason;
             task.retryable = true;
             if (await this.complete(context, ns)) {
-                if (task.status === 'completed' && task.operation === 'release' && task.local_roles.includes('sub')) {
+                if (task.status === 'completed' && task.operation === 'release') {
                     await this.cleanup(context, ns);
                     ns = await this.observe(task.sub_aid);
                 }
@@ -984,13 +1490,28 @@ export class OwnershipWorkflow {
             const accepted = participants(task).every((aid) => task.approvals[aid] === 'accept');
             if (task.operation === 'bind') {
                 if (task.local_roles.includes('owner') && accepted) {
-                    await this.deps.files.declareSubaid(this.fileTask(context));
+                    if (task.legacy_recovery && !task.files.owner) {
+                        const owner = await this.deps.files.readOwner(task.owner_aid, task.sub_aid), checkpoint = task.legacy_recovery.checkpoint.owner_md;
+                        if (owner.exists !== checkpoint.exists || owner.content !== checkpoint.raw || owner.sha256 !== checkpoint.sha256)
+                            throw failure('conflict', 'legacy owner checkpoint was replaced');
+                    }
+                    const prepared = await this.deps.files.declareSubaid(this.fileTask(context));
                     this.enqueue(task, task.sub_aid, 'owner.ready');
-                    if (task.local_roles.includes('sub'))
+                    if (task.local_roles.includes('sub')) {
+                        if (task.legacy_recovery) {
+                            const owner = await this.deps.files.readOwner(task.owner_aid, task.sub_aid);
+                            if (!owner.exists || owner.content !== prepared.raw || owner.sha256 !== prepared.sha256)
+                                throw failure('conflict', 'legacy local owner confirmation differs');
+                            const file = await this.deps.files.verify(owner.content, 'owner', task.sub_aid, task.owner_aid);
+                            if (file.action !== 'declare' || file.statement?.relation_version !== task.target_relation_version)
+                                throw failure('conflict', 'legacy local owner declaration differs');
+                            task.legacy_recovery.owner_confirmed = true;
+                        }
                         task.hints['owner.ready'] = true;
+                    }
                     await this.save(context);
                 }
-                if (task.local_roles.includes('sub') && (task.hints['owner.ready'] || task.approvals[task.owner_aid] === 'accept' || task.files.agent)) {
+                if (task.local_roles.includes('sub') && (task.hints['owner.ready'] || !task.legacy_recovery && task.approvals[task.owner_aid] === 'accept' || task.files.agent) && (!task.legacy_recovery || task.legacy_recovery.owner_confirmed && accepted || task.files.agent)) {
                     await this.deps.files.declareOwneraid(this.fileTask(context));
                 }
                 task.step = accepted ? 'awaiting_confirmation' : 'awaiting_peer_approval';