@agentunion/fastaun 0.5.20 → 0.5.22

package/dist/ownership-workflow.js

@@ -3,6 +3,13 @@ import { isScalar, parseDocument } from 'yaml';
 import { StateError, ValidationError } from './errors.js';
 import { OWNERSHIP_UUID_V4_RE, ownershipAid, ownershipFailure, ownershipInteger, ownershipSha256, parseOwnershipFile, requireOwnershipApplicable } from './ownership-v21.js';
 export const OWNERSHIP_SDK_MESSAGE_TYPE = 'aun.ownership.sdk.v1';
+class OwnershipTaskDecodeError extends StateError {
+    operationId;
+    constructor(operationId, reason) {
+        super(reason, { stringCode: 'persistence_unavailable' });
+        this.operationId = operationId;
+    }
+}
 function participants(task) {
     return [...new Set([task.owner_aid, task.sub_aid, ...(task.new_owner_aid ? [task.new_owner_aid] : [])])];
 }
@@ -43,7 +50,8 @@ export function parseOwnershipMessage(content, context) {
     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 + (message.operation === 'release' ? 0 : 1))
+    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 the operation');
     if (message.operation === 'transfer') {
         if (ownershipAid(message.new_owner_aid, 'new_owner_aid') === message.owner_aid)
@@ -106,8 +114,8 @@ 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 target = message.operation === 'release' ? ns.lock === 'unlocked' && !ns.owner_aid && (ns.relation_version === message.target_relation_version || ns.relation_version === 0) : ns.relation_version === message.target_relation_version && ns.lock === 'locked' && ns.owner_aid === targetOwner(message);
+        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');
     }
@@ -166,6 +174,95 @@ export class OwnershipWorkflow {
             throw ownershipFailure('invalid', 'ownership rejection reason must be a string');
         return this.decide(operationId, 'reject', reason);
     }
+    async resetOwnershipTask() {
+        if (!this.deps.store.loadOwnershipTaskSource || !this.deps.store.resetOwnershipTask)
+            throw ownershipFailure('persistence_unavailable', 'atomic ownership task reset storage is unavailable');
+        const local = this.local(), check = () => { if (this.local() !== local)
+            throw ownershipFailure('conflict', 'ownership reset identity changed'); };
+        const reset = [], skipped = [];
+        for (const snapshot of this.list(true)) {
+            check();
+            if (!OWNERSHIP_UUID_V4_RE.test(snapshot.operation_id)) {
+                skipped.push(snapshot.operation_id);
+                continue;
+            }
+            let source = this.taskSource(snapshot.operation_id);
+            for (let attempt = 0; source; attempt++) {
+                let task;
+                try {
+                    const parsed = JSON.parse(source.source);
+                    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+                        task = parsed;
+                }
+                catch { }
+                if (task && Object.hasOwn(task, 'task_reset')) {
+                    try {
+                        this.decode({ operation_id: source.operation_id, revision: source.revision, task });
+                    }
+                    catch {
+                        skipped.push(snapshot.operation_id);
+                    }
+                    break;
+                }
+                let initiator;
+                try {
+                    initiator = ownershipAid(task?.initiator_aid, 'initiator_aid');
+                }
+                catch { }
+                if (!task || !initiator || !['pending', 'completed', 'rejected', 'stopped', 'error'].includes(task.status)) {
+                    skipped.push(snapshot.operation_id);
+                    break;
+                }
+                if (initiator !== local || ['completed', 'rejected', 'stopped'].includes(task.status))
+                    break;
+                let subject;
+                try {
+                    subject = ownershipAid(task.sub_aid, 'sub_aid');
+                }
+                catch { }
+                try {
+                    const original = source, result = await this.runSerialized(subject ?? source.operation_id, () => { check(); return this.resetSource(original, subject); });
+                    check();
+                    if (result.created)
+                        reset.push(source.operation_id);
+                    break;
+                }
+                catch (error) {
+                    check();
+                    if (attempt > 0 || !(error instanceof StateError) || error.stringCode !== 'conflict')
+                        throw error;
+                    source = this.taskSource(snapshot.operation_id);
+                }
+            }
+        }
+        check();
+        return { reset_operation_ids: [...new Set(reset)].sort(), skipped_operation_ids: [...new Set(skipped)].sort() };
+    }
+    async resetTask(operationId) {
+        if (typeof operationId !== 'string' || !OWNERSHIP_UUID_V4_RE.test(operationId))
+            throw ownershipFailure('invalid', 'ownership operation_id is invalid');
+        const source = this.taskSource(operationId);
+        if (!source)
+            throw ownershipFailure('operation_not_found', 'no local ownership task matches operation_id');
+        let task = {};
+        try {
+            const parsed = JSON.parse(source.source);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+                task = parsed;
+        }
+        catch { }
+        if (Object.hasOwn(task, 'task_reset')) {
+            this.decode({ operation_id: operationId, revision: source.revision, task });
+            return { operation_id: operationId, reset: true };
+        }
+        let subject;
+        try {
+            subject = ownershipAid(task.sub_aid, 'sub_aid');
+        }
+        catch { }
+        await this.runSerialized(subject ?? operationId, () => this.resetSource(source, subject));
+        return { operation_id: operationId, reset: true };
+    }
     async checkOwnershipConsensus(subAid = this.local()) {
         return this.deps.files.checkConsensus(ownershipAid(subAid, 'sub_aid'));
     }
@@ -188,8 +285,12 @@ export class OwnershipWorkflow {
             return true;
         let message;
         try {
+            const saved = this.load(String(body.operation_id));
+            if (saved && this.isReset(saved.record))
+                return true;
+            const task = saved && !saved.record.base_agent_md && saved.record.request_verified && !['completed', 'stopped', 'rejected'].includes(saved.record.status) ? this.legacyTaskView(saved.record) : saved?.record;
             message = parseOwnershipMessage(content, { authenticated_from_aid: from, local_aid: this.local(),
-                task: ['bind.request', 'transfer.request'].includes(String(body.action)) || body.operation === 'release' && body.action === 'relation.confirmed' ? undefined : this.load(String(body.operation_id))?.record });
+                task: task ?? (['bind.request', 'transfer.request'].includes(String(body.action)) || body.operation === 'release' && body.action === 'relation.confirmed' ? undefined : saved?.record) });
         }
         catch (error) {
             if (error instanceof StateError && error.stringCode === 'persistence_unavailable')
@@ -209,12 +310,14 @@ export class OwnershipWorkflow {
         return this.runSerialized(message.sub_aid, async () => {
             let handle = this.load(message.operation_id);
             if (handle) {
+                const task = !handle.record.base_agent_md && handle.record.request_verified && !['completed', 'stopped', 'rejected'].includes(handle.record.status) ? this.legacyTaskView(handle.record) : handle.record;
                 try {
-                    parseOwnershipMessage(content, { authenticated_from_aid: from, local_aid: this.local(), task: handle.record });
+                    parseOwnershipMessage(content, { authenticated_from_aid: from, local_aid: this.local(), task });
                 }
                 catch {
                     return true;
                 }
+                await this.upgradeLegacy(handle);
             }
             else {
                 if (!['bind.request', 'transfer.request'].includes(message.action) && !(message.operation === 'release' && message.action === 'relation.confirmed'))
@@ -249,6 +352,10 @@ export class OwnershipWorkflow {
         for (const snapshot of this.list(true)) {
             try {
                 const record = this.decode(snapshot).record;
+                if (this.isReset(record))
+                    continue;
+                if (!record.base_agent_md && record.request_verified && ['completed', 'stopped', 'rejected'].includes(record.status))
+                    continue;
                 await this.runSerialized(record.sub_aid, async () => {
                     const handle = this.load(record.operation_id);
                     await this.drive(handle);
@@ -290,11 +397,116 @@ export class OwnershipWorkflow {
             throw ownershipFailure('persistence_unavailable', error instanceof Error ? error.message : String(error));
         }
     }
+    taskSource(operationId) {
+        try {
+            if (!this.deps.store.loadOwnershipTaskSource || !this.deps.store.resetOwnershipTask)
+                throw new Error('atomic ownership task reset storage is unavailable');
+            return this.deps.store.loadOwnershipTaskSource(this.local(), operationId);
+        }
+        catch (error) {
+            throw ownershipFailure('persistence_unavailable', error instanceof Error ? error.message : String(error));
+        }
+    }
+    async resetSource(source, subject) {
+        const task = { protocol: '2.1', operation_id: source.operation_id, local_aid: this.local(), status: 'stopped', step: 'reset',
+            ...(subject ? { sub_aid: subject } : {}), task_reset: { source: source.source, source_sha256: ownershipSha256(source.source), revision: source.revision, reset_at: Math.trunc(Date.now() / 1000) } };
+        try {
+            const saved = this.deps.store.resetOwnershipTask(this.local(), source.operation_id, source.revision, source.source, task);
+            this.decode(saved);
+            if (!this.isReset(saved.task))
+                throw new Error('ownership reset marker was not saved');
+            const committed = this.taskSource(source.operation_id);
+            if (!committed || committed.revision !== saved.revision || JSON.stringify(JSON.parse(committed.source)) !== JSON.stringify(saved.task))
+                throw new Error('ownership reset marker readback failed');
+            return { operation_id: source.operation_id, reset: true, created: true };
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !/snapshot|revision conflict|already reset/.test(error.message))
+                throw ownershipFailure('persistence_unavailable', error instanceof Error ? error.message : String(error));
+            const winner = this.taskSource(source.operation_id);
+            if (winner) {
+                let parsed;
+                try {
+                    parsed = JSON.parse(winner.source);
+                }
+                catch { }
+                if (parsed && typeof parsed === 'object' && Object.hasOwn(parsed, 'task_reset')) {
+                    this.decode({ operation_id: winner.operation_id, revision: winner.revision, task: parsed });
+                    return { operation_id: source.operation_id, reset: true, created: false };
+                }
+            }
+            throw ownershipFailure(error instanceof Error && /revision|snapshot|conflict/.test(error.message) ? 'conflict' : 'persistence_unavailable', error instanceof Error ? error.message : String(error));
+        }
+    }
+    isReset(record) { return Object.hasOwn(record, 'task_reset'); }
+    async resetUnusableTasks(subAid, ownerAid) {
+        for (const snapshot of this.list(true)) {
+            if (this.isReset(snapshot.task)) {
+                this.decode(snapshot);
+                continue;
+            }
+            if (snapshot.task.sub_aid !== subAid)
+                continue;
+            if (!this.isReset(snapshot.task) && ['completed', 'rejected', 'stopped'].includes(snapshot.task.status))
+                continue;
+            let record;
+            let unusable = false;
+            try {
+                record = this.decode(snapshot).record;
+            }
+            catch (error) {
+                if (this.isReset(snapshot.task) || !(error instanceof OwnershipTaskDecodeError) || error.operationId !== snapshot.operation_id)
+                    throw error;
+                unusable = true;
+                record = snapshot.task;
+            }
+            if (!unusable && !this.isReset(record) && !record.base_agent_md && record.request_verified && !['completed', 'stopped', 'rejected'].includes(record.status) && record.operation === 'bind' && record.owner_aid === ownerAid && record.initiator_aid === this.local()) {
+                try {
+                    this.legacyTaskView(record);
+                }
+                catch {
+                    unusable = true;
+                }
+            }
+            if (!unusable)
+                continue;
+            const source = this.taskSource(snapshot.operation_id);
+            if (!source || source.revision !== snapshot.revision)
+                throw ownershipFailure('conflict', 'ownership task advanced before automatic reset');
+            let parsed;
+            try {
+                parsed = JSON.parse(source.source);
+            }
+            catch { }
+            if (!parsed || typeof parsed !== 'object' || parsed.sub_aid !== subAid)
+                throw ownershipFailure('persistence_unavailable', 'ownership task subject cannot be established for automatic reset');
+            if (Object.hasOwn(parsed, 'task_reset'))
+                throw ownershipFailure('persistence_unavailable', 'ownership reset marker is corrupt');
+            if (['completed', 'rejected', 'stopped'].includes(parsed.status))
+                continue;
+            await this.resetSource(source, subAid);
+        }
+    }
     decode(snapshot) {
         const record = snapshot.task;
         try {
+            if (this.isReset(record)) {
+                const task = snapshot.task, reset = task.task_reset;
+                if (task.protocol !== '2.1' || task.operation_id !== snapshot.operation_id || !OWNERSHIP_UUID_V4_RE.test(snapshot.operation_id) || task.local_aid !== this.local() || task.status !== 'stopped' || task.step !== 'reset' || Object.keys(task).some((key) => !['protocol', 'operation_id', 'local_aid', 'status', 'step', 'sub_aid', 'task_reset'].includes(key)) || !reset || typeof reset !== 'object' || Array.isArray(reset) || Object.keys(reset).length !== 4 || typeof reset.source !== 'string' || reset.source_sha256 !== ownershipSha256(reset.source) || !Number.isSafeInteger(reset.revision) || Number(reset.revision) < 1 || Number(reset.revision) + 1 !== snapshot.revision || !Number.isSafeInteger(reset.reset_at) || Number(reset.reset_at) <= 0)
+                    throw new Error('ownership reset marker is corrupt');
+                let subject;
+                try {
+                    subject = ownershipAid(JSON.parse(reset.source).sub_aid, 'sub_aid');
+                }
+                catch { }
+                if (task.sub_aid !== subject)
+                    throw new Error('ownership reset subject changed');
+                return { record, revision: snapshot.revision };
+            }
             if (record.protocol !== '2.1' || typeof record.operation_id !== 'string' || !OWNERSHIP_UUID_V4_RE.test(record.operation_id) || record.operation_id !== snapshot.operation_id || !['bind', 'release', 'transfer'].includes(record.operation) || !['pending', 'completed', 'rejected', 'stopped', 'error'].includes(record.status) || typeof record.step !== 'string')
                 throw new Error('invalid ownership task');
+            if (!record.base_agent_md && record.request_verified && !record.legacy_task)
+                return { record, revision: snapshot.revision };
             ownershipAid(record.sub_aid, 'sub_aid');
             ownershipAid(record.owner_aid, 'owner_aid');
             ownershipAid(record.initiator_aid, 'initiator_aid');
@@ -304,28 +516,82 @@ export class OwnershipWorkflow {
             }
             else if (record.new_owner_aid !== undefined)
                 throw new Error('unexpected transfer target');
-            if (ownershipInteger(record.target_relation_version, 'target_relation_version') !== ownershipInteger(record.base_relation_version, 'base_relation_version', 0) + (record.operation === 'release' ? 0 : 1) || !participants(record).includes(record.initiator_aid) || record.operation !== 'bind' && record.initiator_aid !== record.owner_aid)
+            const baseVersion = ownershipInteger(record.base_relation_version, 'base_relation_version', 0), targetVersion = ownershipInteger(record.target_relation_version, 'target_relation_version');
+            if (targetVersion !== baseVersion + 1 && !(record.operation === 'release' && targetVersion === baseVersion) || !participants(record).includes(record.initiator_aid) || record.operation !== 'bind' && record.initiator_aid !== record.owner_aid)
                 throw new Error('invalid fixed ownership context');
             if (JSON.stringify(record.local_roles) !== JSON.stringify(localRoles(record, this.local())) || !record.local_roles.length || !['pending', 'accept', 'reject'].includes(record.local_decision) || !record.approvals || participants(record).some((aid) => !['pending', 'accept', 'reject'].includes(record.approvals[aid])) || record.approvals[this.local()] !== record.local_decision || !record.files || typeof record.files !== 'object' || Array.isArray(record.files) || !Array.isArray(record.inbox) || !Array.isArray(record.outbox) || !Array.isArray(record.received) || !Array.isArray(record.notices) || typeof record.request_verified !== 'boolean' || typeof record.request_notified !== 'boolean')
                 throw new Error('ownership approval or pending state is corrupt');
             if (Object.keys(record.approvals).length !== participants(record).length || record.approvals[record.initiator_aid] !== 'accept' || record.initiator_aid === this.local() && record.local_decision !== 'accept')
                 throw new Error('ownership initiator or approval participants are corrupt');
-            if (record.request_verified) {
+            if (record.legacy_recovery !== undefined) {
+                const recovery = record.legacy_recovery, original = recovery.task, checkpoint = recovery.checkpoint;
+                if (!original || record.request_verified !== true || recovery.task_sha256 !== ownershipSha256(JSON.stringify(original)) || !Number.isSafeInteger(recovery.revision) || recovery.revision < 1 || recovery.revision >= snapshot.revision || !checkpoint || !Number.isSafeInteger(checkpoint.observed_at) || checkpoint.observed_at <= 0 || typeof recovery.owner_confirmed !== 'boolean')
+                    throw new Error('legacy recovery checkpoint is corrupt');
+                this.legacyView(original);
+                if (['operation_id', 'operation', 'sub_aid', 'owner_aid', 'initiator_aid', 'base_relation_version', 'target_relation_version'].some((key) => original[key] !== record[key]) || JSON.stringify(checkpoint.agent_md) !== JSON.stringify(record.base_agent_md) || original.local_decision !== 'pending' && original.local_decision !== record.local_decision || participants(record).some((name) => original.approvals[name] !== 'pending' && original.approvals[name] !== record.approvals[name]))
+                    throw new Error('legacy recovery original context or approval changed');
+                const owner = checkpoint.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('legacy recovery owner observation is corrupt');
+                if (owner.exists) {
+                    const file = parseOwnershipFile(owner.raw, 'owner', { expectedSubAid: record.sub_aid, expectedOwnerAid: record.owner_aid });
+                    if (file.action !== 'declare' || file.statement?.relation_version !== 1)
+                        throw new Error('legacy recovery owner observation changed');
+                }
+                const originalOwner = original.files.owner, pinned = record.files.owner;
+                if ((originalOwner || owner.exists) && (!pinned || pinned.raw !== (originalOwner?.raw ?? owner.raw) || pinned.hash !== (originalOwner?.hash ?? owner.sha256) || JSON.stringify(pinned.original_owner) !== JSON.stringify(owner)) || originalOwner && (!owner.exists || originalOwner.raw !== owner.raw || originalOwner.hash !== owner.sha256))
+                    throw new Error('legacy recovery owner candidate changed');
+                if (this.local() === record.owner_aid ? !recovery.owner_confirmed : recovery.owner_confirmed ? !record.received.includes(`${record.owner_aid}|${record.operation_id}|owner.ready`) : Boolean(record.files.agent) || record.status === 'completed')
+                    throw new Error('legacy recovery owner confirmation is corrupt');
+            }
+            if (record.legacy_task) {
+                const recovery = record.legacy_task, original = recovery.task;
+                if (!Number.isSafeInteger(recovery.revision) || recovery.revision < 1 || recovery.revision >= snapshot.revision || recovery.task_sha256 !== ownershipSha256(JSON.stringify(original)))
+                    throw new Error('legacy task source is corrupt');
+                this.priorView(original);
+                if (['operation_id', 'operation', 'sub_aid', 'owner_aid', 'new_owner_aid', 'initiator_aid', 'base_relation_version', 'target_relation_version'].some((key) => original[key] !== record[key]) || Object.entries(original.approvals).some(([aid, decision]) => decision !== 'pending' && record.approvals[aid] !== decision) || JSON.stringify(recovery.checkpoint.agent_md) !== JSON.stringify(record.base_agent_md ?? null) || JSON.stringify(recovery.checkpoint.owner_md) !== JSON.stringify(record.base_owner_md ?? null) || !record.base_agent_md && record.status !== 'completed')
+                    throw new Error('legacy task fixed context changed');
+                for (const [key, saved] of Object.entries(original.files))
+                    if (record.files[key]?.raw !== saved.raw || record.files[key]?.hash !== saved.hash || key === 'agent' && JSON.stringify(record.files[key]?.condition) !== JSON.stringify(saved.condition))
+                        throw new Error('legacy task signed candidate changed');
+            }
+            if (record.request_verified && (record.base_agent_md || !record.legacy_task)) {
                 const base = record.base_agent_md;
-                if (!base || base.exists !== true || typeof base.raw !== 'string' || base.sha256 !== ownershipSha256(base.raw) || typeof base.etag !== 'string' || !base.etag)
+                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 = parseOwnershipFile(base.raw, 'agent', { expectedSubAid: record.sub_aid }).statement ?? null;
-                if (JSON.stringify(statement) !== JSON.stringify(base.statement) || (statement?.relation_version ?? 0) !== record.base_relation_version)
+                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 && !(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) {
@@ -371,7 +637,7 @@ export class OwnershipWorkflow {
             if (record.status === 'completed') {
                 const evidence = record.completion_evidence;
                 const cleaned = record.operation === 'release' && evidence?.status === 'unbound' && evidence.relation_version === 0 && record.cleanup_status === 'cleaned' && Boolean(this.cleanupEvidence(record, evidence));
-                if (!evidence || evidence.sub_aid !== record.sub_aid || !cleaned && (evidence.relation_version !== record.target_relation_version || evidence.status !== (record.operation === 'release' ? 'released' : 'consensus')) || evidence.lock !== (record.operation === 'release' ? 'unlocked' : 'locked') || evidence.owner_aid !== (record.operation === 'release' ? null : targetOwner(record)) || typeof evidence.agent_md_etag !== 'string' || !evidence.agent_md_etag || !/^[0-9a-f]{64}$/.test(evidence.agent_md_sha256) || typeof evidence.owner_md_sha256 !== 'string' || record.operation !== 'release' && !/^[0-9a-f]{64}$/.test(evidence.owner_md_sha256))
+                if (!evidence || evidence.sub_aid !== record.sub_aid || !cleaned && (evidence.relation_version !== (record.operation === 'release' ? record.base_relation_version : record.target_relation_version) || evidence.status !== (record.operation === 'release' ? 'released' : 'consensus')) || evidence.lock !== (record.operation === 'release' ? 'unlocked' : 'locked') || evidence.owner_aid !== (record.operation === 'release' ? null : targetOwner(record)) || typeof evidence.agent_md_etag !== 'string' || !evidence.agent_md_etag || !/^[0-9a-f]{64}$/.test(evidence.agent_md_sha256) || typeof evidence.owner_md_sha256 !== 'string' || record.operation !== 'release' && !/^[0-9a-f]{64}$/.test(evidence.owner_md_sha256))
                     throw new Error('ownership target acceptance evidence is corrupt');
                 if (record.operation !== 'release' && (record.local_roles.includes('sub') && record.files.agent?.hash !== evidence.agent_md_sha256 || this.local() === targetOwner(record) && record.files.owner?.hash !== evidence.owner_md_sha256 || record.operation === 'transfer' && record.local_roles.includes('owner') && !record.files.transfer))
                     throw new Error('ownership target file evidence is missing');
@@ -381,8 +647,195 @@ export class OwnershipWorkflow {
             return { record, revision: snapshot.revision };
         }
         catch (error) {
-            throw ownershipFailure('persistence_unavailable', error instanceof Error ? error.message : String(error));
+            if (error instanceof StateError && error.stringCode === 'persistence_unavailable')
+                throw error;
+            throw new OwnershipTaskDecodeError(snapshot.operation_id, error instanceof Error ? error.message : String(error));
+        }
+    }
+    legacyTaskView(record) {
+        return record.operation === 'bind' && record.base_relation_version === 0 && record.initiator_aid === record.sub_aid && Object.keys(record.files ?? {}).every((key) => key === 'owner') ? this.legacyView(record) : this.priorView(record);
+    }
+    legacyView(record) {
+        if (Object.hasOwn(record, 'legacy_recovery') || record.protocol !== '2.1' || record.operation !== 'bind' || record.base_relation_version !== 0 || record.target_relation_version !== 1 || record.initiator_aid !== record.sub_aid || record.request_verified !== true || record.status !== 'pending' && !(record.status === 'error' && record.retryable === true) || record.base_agent_md != null || record.base_owner_md != null || !record.files || typeof record.files !== 'object' || Array.isArray(record.files) || Object.keys(record.files).some((key) => key !== 'owner') || record.local_decision === 'reject' || Object.values(record.approvals ?? {}).includes('reject'))
+            throw ownershipFailure('unsupported_protocol', 'legacy ownership task cannot be recovered automatically');
+        const view = JSON.parse(JSON.stringify(record));
+        view.request_verified = false;
+        view.files = {};
+        view.inbox = record.inbox?.map((item) => ({ from: item.from, payload: this.legacyMessage(item.payload) }));
+        view.outbox = record.outbox?.map((item) => ({ to: item.to, payload: this.legacyMessage(item.payload) }));
+        this.decode({ operation_id: record.operation_id, revision: 1, task: view });
+        for (const notice of record.notices) {
+            if (typeof notice !== 'string' || notice.split('|').length !== 2)
+                throw ownershipFailure('unsupported_protocol', 'legacy ownership notice is corrupt');
+            const [to, action] = notice.split('|');
+            this.validateOutgoing(view, { to: to, payload: { type: OWNERSHIP_SDK_MESSAGE_TYPE, operation_id: record.operation_id, operation: record.operation, action: action, sub_aid: record.sub_aid, owner_aid: record.owner_aid, base_relation_version: 0, target_relation_version: 1 } });
+        }
+        const saved = record.files.owner;
+        if (saved) {
+            if (this.local() !== record.owner_aid || record.local_decision !== 'accept' || typeof saved.raw !== 'string' || saved.hash !== ownershipSha256(saved.raw) || !saved.condition || Object.keys(saved.condition).length !== 1 || typeof saved.condition.expected_revision !== 'string' || !saved.condition.expected_revision || saved.published_revision !== undefined && (typeof saved.published_revision !== 'string' || !saved.published_revision))
+                throw ownershipFailure('unsupported_protocol', 'legacy owner candidate cannot be recovered automatically');
+            const file = parseOwnershipFile(saved.raw, 'owner', { expectedSubAid: record.sub_aid, expectedOwnerAid: record.owner_aid });
+            if (file.action !== 'declare' || file.statement?.relation_version !== 1)
+                throw ownershipFailure('unsupported_protocol', 'legacy owner candidate does not match this task');
+        }
+        return view;
+    }
+    legacyMessage(content) {
+        if (!content || typeof content !== 'object' || Array.isArray(content))
+            throw ownershipFailure('unsupported_protocol', 'legacy ownership message is corrupt');
+        return { ...content };
+    }
+    async upgradeLegacy(handle) {
+        if (Boolean(handle.record.base_agent_md) || !handle.record.request_verified || ['completed', 'stopped', 'rejected'].includes(handle.record.status))
+            return;
+        if (handle.record.operation !== 'bind' || handle.record.base_relation_version !== 0 || handle.record.initiator_aid !== handle.record.sub_aid || Object.keys(handle.record.files ?? {}).some((key) => key !== 'owner'))
+            return this.upgradePrior(handle);
+        const original = JSON.parse(JSON.stringify(handle.record));
+        const record = this.legacyView(original);
+        for (const snapshot of this.list(true)) {
+            if (snapshot.operation_id === record.operation_id || snapshot.task.sub_aid !== record.sub_aid)
+                continue;
+            const other = this.decode(snapshot).record;
+            if (!other.base_agent_md && other.request_verified && !['completed', 'stopped', 'rejected'].includes(other.status))
+                this.legacyTaskView(other);
+            if (other.status === 'pending' || other.status === 'error' && other.retryable)
+                throw ownershipFailure('conflict', 'a different active ownership intent already exists');
+        }
+        const ns = await this.readNs(record.sub_aid);
+        if ((ns.exists ? parseOwnershipFile(ns.content, 'agent', { expectedSubAid: record.sub_aid }).frontmatter.type : record.sub_aid === this.local() ? this.deps.currentType?.() : undefined) === 'human')
+            throw ownershipFailure('invalid', 'human cannot declare an owner');
+        if (ns.lock === 'locked' && ns.owner_aid === record.owner_aid && ns.relation_version === record.target_relation_version)
+            return this.upgradePrior(handle);
+        if (ns.lock !== 'unlocked' || ns.relation_version !== 0 || ns.owner_aid || ns.exists && parseOwnershipFile(ns.content, 'agent', { expectedSubAid: record.sub_aid }).statement)
+            throw ownershipFailure('conflict', 'legacy ownership relation has changed');
+        const current = await this.deps.files.readOwner(record.owner_aid, record.sub_aid);
+        if (current.exists) {
+            const file = await this.deps.files.verifyFile(current.content, 'owner', record.sub_aid, record.owner_aid);
+            if (file.action !== 'declare' || file.statement?.relation_version !== 1)
+                throw ownershipFailure('conflict', 'legacy owner declaration has changed');
+        }
+        const candidate = original.files.owner;
+        if (candidate) {
+            await this.deps.files.verifyFile(candidate.raw, 'owner', record.sub_aid, record.owner_aid);
+            if (!current.exists || current.content !== candidate.raw || current.sha256 !== candidate.hash)
+                throw ownershipFailure('conflict', 'legacy owner candidate was replaced');
+            if (candidate.published_revision !== undefined && current.revision !== candidate.published_revision)
+                throw ownershipFailure(current.revision ? 'conflict' : 'unavailable', 'legacy published owner revision changed', !current.revision);
         }
+        else if (this.local() === record.owner_aid && current.exists)
+            throw ownershipFailure('unsupported_protocol', 'legacy owner declaration lacks a local task candidate');
+        const owner = { exists: current.exists, raw: current.content, sha256: current.exists ? ownershipSha256(current.content) : '', ...(candidate && current.revision ? { revision: current.revision } : {}) };
+        record.status = 'pending';
+        record.step = 'approval';
+        record.retryable = true;
+        record.request_verified = true;
+        delete record.code;
+        delete record.reason;
+        record.inbox = [];
+        record.received = [];
+        record.outbox = [];
+        record.notices = [];
+        await this.captureBase(record, ns);
+        if (candidate || current.exists && this.local() === record.sub_aid)
+            record.files.owner = { raw: candidate?.raw ?? current.content, hash: candidate?.hash ?? current.sha256, condition: {}, original_owner: owner };
+        record.legacy_recovery = { task: original, revision: handle.revision, task_sha256: ownershipSha256(JSON.stringify(original)), checkpoint: { observed_at: Math.trunc(Date.now() / 1000), agent_md: record.base_agent_md, owner_md: owner }, owner_confirmed: this.local() === record.owner_aid };
+        if (this.local() === record.sub_aid)
+            this.enqueue(record, record.owner_aid, 'bind.request');
+        else if (record.local_decision === 'accept')
+            this.enqueue(record, record.sub_aid, 'bind.accept');
+        const after = await this.readNs(record.sub_aid), afterOwner = await this.deps.files.readOwner(record.owner_aid, record.sub_aid);
+        if (after.exists !== ns.exists || after.content !== ns.content || after.etag !== ns.etag || after.relation_version !== 0 || after.lock !== 'unlocked' || afterOwner.exists !== current.exists || afterOwner.content !== current.content || afterOwner.sha256 !== current.sha256)
+            throw ownershipFailure('conflict', 'legacy recovery observations changed');
+        const recovered = { record, revision: handle.revision };
+        this.decode({ operation_id: record.operation_id, revision: handle.revision + 1, task: record });
+        try {
+            await this.save(recovered);
+        }
+        catch (error) {
+            if (error instanceof StateError && error.stringCode === 'persistence_unavailable' && error.message.includes('active ownership task already exists'))
+                throw ownershipFailure('conflict', 'a different active ownership intent already exists');
+            throw error;
+        }
+        handle.record = record;
+        handle.revision = recovered.revision;
+    }
+    priorView(original) {
+        if (original.base_agent_md != null || original.base_owner_md != null || original.legacy_task || original.legacy_recovery || !original.request_verified || !['pending', 'error'].includes(original.status) || original.status === 'error' && !original.retryable || Object.values(original.approvals ?? {}).includes('reject'))
+            throw ownershipFailure('unsupported_protocol', 'legacy task context cannot be recovered');
+        const record = structuredClone(original);
+        record.request_verified = false;
+        for (const [key, saved] of Object.entries(record.files ?? {})) {
+            const owner = key === 'owner' ? targetOwner(record) : record.owner_aid;
+            if (this.local() !== (key === 'agent' ? record.sub_aid : owner))
+                throw ownershipFailure('unsupported_protocol', 'legacy file local role is invalid');
+            if (key !== 'agent' && key !== 'cleanup') {
+                const condition = saved.condition;
+                if (!saved.original_owner && (!condition || Object.keys(condition).length !== 1 || typeof condition.expected_revision !== 'string' || !condition.expected_revision))
+                    throw ownershipFailure('unsupported_protocol', 'legacy owner condition is invalid');
+                saved.condition = {};
+                saved.original_owner ??= { exists: false, raw: '', sha256: '' };
+            }
+        }
+        try {
+            this.decode({ operation_id: original.operation_id, revision: 1, task: record });
+        }
+        catch (error) {
+            throw ownershipFailure('unsupported_protocol', error instanceof Error ? error.message : String(error));
+        }
+        return record;
+    }
+    async upgradePrior(handle) {
+        const original = structuredClone(handle.record), record = this.priorView(original);
+        for (const snapshot of this.list(true)) {
+            if (snapshot.operation_id === record.operation_id || snapshot.task.sub_aid !== record.sub_aid)
+                continue;
+            const other = this.decode(snapshot).record;
+            if (other.status === 'pending' || other.status === 'error' && other.retryable)
+                throw ownershipFailure('conflict', 'a different active ownership intent already exists');
+        }
+        const ns = await this.readNs(record.sub_aid);
+        if ((ns.exists ? parseOwnershipFile(ns.content, 'agent', { expectedSubAid: record.sub_aid }).frontmatter.type : record.sub_aid === this.local() ? this.deps.currentType?.() : undefined) === 'human')
+            throw ownershipFailure('invalid', 'human cannot declare an owner');
+        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;
+        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);
+        for (const [key, saved] of Object.entries(record.files)) {
+            const owner = key === 'owner' || key === 'agent' ? targetOwner(record) : record.owner_aid;
+            await this.deps.files.verifyFile(saved.raw, key === 'agent' ? 'agent' : 'owner', record.sub_aid, owner);
+            if (key === 'agent')
+                continue;
+            const current = await this.deps.files.readOwner(owner, record.sub_aid);
+            const source = original.files[key];
+            const revision = source.condition.expected_revision;
+            if (revision && (current.content === saved.raw && source.published_revision !== undefined || !committed && current.content !== saved.raw)) {
+                if (!current.revision)
+                    throw ownershipFailure('unavailable', 'legacy owner original revision is unavailable', true);
+                if (current.revision !== (current.content === saved.raw ? source.published_revision : revision))
+                    throw ownershipFailure('conflict', 'legacy owner original revision changed');
+            }
+            const currentStatement = current.exists ? parseOwnershipFile(current.content, 'owner', { expectedSubAid: record.sub_aid }).statement : undefined;
+            const expected = parseOwnershipFile(saved.raw, 'owner', { expectedSubAid: record.sub_aid }).statement;
+            const same = expected && currentStatement && Object.keys(expected).every((field) => expected[field] === currentStatement[field]);
+            if (current.content !== saved.raw && (source.published_revision !== undefined || current.exists && (key === 'owner' || !same)) && !committed)
+                throw ownershipFailure('conflict', 'legacy signed owner file was replaced');
+            saved.original_owner = { exists: current.exists, raw: current.content, sha256: current.exists ? current.sha256 : '', ...(revision && current.revision ? { revision: current.revision } : {}) };
+        }
+        record.request_verified = true;
+        record.legacy_task = { task: original, revision: handle.revision, task_sha256: ownershipSha256(JSON.stringify(original)), checkpoint: { agent_md: record.base_agent_md ?? null, owner_md: record.base_owner_md ?? null } };
+        const recovered = { record, revision: handle.revision };
+        if (committed) {
+            if (!await this.confirm(recovered))
+                throw ownershipFailure('conflict', 'legacy committed target lacks matching local signed evidence');
+        }
+        else
+            await this.save(recovered);
+        handle.record = record;
+        handle.revision = recovered.revision;
     }
     async save(handle) {
         try {
@@ -448,23 +901,44 @@ 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;
     }
     async start(operation, subAid, ownerAid, newOwnerAid, operationId) {
         this.requireApplicable(subAid);
         return this.runSerialized(subAid, async () => {
+            if (operation === 'bind' && !operationId)
+                await this.resetUnusableTasks(subAid, ownerAid);
             const existing = operationId ? this.load(operationId) : null;
             if (existing) {
+                if (this.isReset(existing.record))
+                    throw ownershipFailure('conflict', 'ownership task was reset');
+                await this.upgradeLegacy(existing);
                 const record = existing.record;
+                if (!record.base_agent_md && record.request_verified)
+                    throw ownershipFailure('unsupported_protocol', 'legacy ownership task requires explicit migration');
                 if (record.operation !== operation || record.sub_aid !== subAid || record.owner_aid !== ownerAid || record.new_owner_aid !== newOwnerAid || record.initiator_aid !== this.local())
                     throw ownershipFailure('conflict', 'saved registration task context changed');
                 await this.drive(existing);
                 return ownershipTaskResult(record);
             }
             let ns;
-            for (const snapshot of this.list()) {
-                const active = this.decode(snapshot), record = active.record;
+            for (const snapshot of this.list(true)) {
+                if (snapshot.task.sub_aid !== subAid)
+                    continue;
+                const active = this.decode(snapshot);
+                if (this.isReset(active.record))
+                    continue;
+                if (!active.record.base_agent_md && active.record.request_verified && ['completed', 'stopped', 'rejected'].includes(active.record.status))
+                    continue;
+                if (!active.record.base_agent_md && active.record.request_verified && (active.record.operation !== operation || active.record.owner_aid !== ownerAid || active.record.new_owner_aid !== newOwnerAid || active.record.initiator_aid !== this.local()))
+                    throw ownershipFailure('conflict', 'a different active ownership intent already exists');
+                await this.upgradeLegacy(active);
+                const record = active.record;
+                if (!record.base_agent_md && record.request_verified)
+                    throw ownershipFailure('unsupported_protocol', 'legacy ownership task cannot be recovered automatically');
                 if (record.sub_aid !== subAid || record.status !== 'pending' && !(record.status === 'error' && record.retryable))
                     continue;
                 const same = record.operation === operation && record.owner_aid === ownerAid && record.new_owner_aid === newOwnerAid && record.initiator_aid === this.local();
@@ -477,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);
@@ -488,7 +962,7 @@ export class OwnershipWorkflow {
                         base = false;
                     }
                 }
-                const target = record.operation === 'release' ? ns.lock === 'unlocked' && !ns.owner_aid && (ns.relation_version === record.target_relation_version || ns.relation_version === 0) : ns.relation_version === record.target_relation_version && ns.lock === 'locked' && ns.owner_aid === targetOwner(record);
+                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);
                 if (!base && !target) {
                     await this.recordError(active, ownershipFailure('conflict', 'the operation was superseded by a different relation result'));
                     const result = ownershipTaskResult(record);
@@ -508,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 (!ns.exists)
-                throw ownershipFailure('unavailable', 'initial agent.md is not published', true);
-            if (operation === 'bind' && parseOwnershipFile(ns.content, 'agent', { expectedSubAid: subAid }).frontmatter.type === 'human')
+            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' && 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);
@@ -536,14 +1012,21 @@ export class OwnershipWorkflow {
         const initial = this.load(operationId);
         if (!initial)
             throw ownershipFailure('operation_not_found', 'no local ownership request matches operation_id');
+        if (this.isReset(initial.record))
+            throw ownershipFailure('conflict', 'ownership task was reset');
         return this.runSerialized(initial.record.sub_aid, async () => {
             const handle = this.load(operationId);
+            await this.upgradeLegacy(handle);
             const record = handle.record;
+            if (!record.base_agent_md && record.request_verified)
+                throw ownershipFailure('unsupported_protocol', 'legacy ownership task requires explicit migration');
             if (record.operation === 'release' || record.initiator_aid === this.local() || !record.request_verified)
                 throw ownershipFailure('forbidden', 'this task is not a verified local approval request');
             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);
             }
@@ -552,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';
@@ -571,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;
@@ -583,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)
@@ -598,7 +1120,7 @@ export class OwnershipWorkflow {
                 throw new Error('ownership outgoing action lacks participant approvals');
         }
         catch (error) {
-            throw ownershipFailure('persistence_unavailable', error instanceof Error ? error.message : String(error));
+            throw new OwnershipTaskDecodeError(record.operation_id, error instanceof Error ? error.message : String(error));
         }
     }
     async flush(handle) {
@@ -612,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 target = record.operation === 'release' ? ns.lock === 'unlocked' && !ns.owner_aid && (ns.relation_version === record.target_relation_version || ns.relation_version === 0) : ns.relation_version === record.target_relation_version && ns.lock === 'locked' && ns.owner_aid === targetOwner(record);
+            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;
@@ -629,7 +1151,12 @@ export class OwnershipWorkflow {
                 if (expiresAt <= Math.trunc(Date.now() / 1000))
                     throw ownershipFailure('conflict', 'transfer authorization expired');
             }
-            await this.deps.send(message.to, message.payload);
+            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, message.message_id);
             handle.record.outbox.shift();
             await this.save(handle);
         }
@@ -642,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 = parseOwnershipFile(ns.content, 'agent', { expectedSubAid: record.sub_aid }).statement ?? null;
-        record.base_agent_md = { exists: ns.exists, raw: ns.content, sha256: ownershipSha256(ns.content), etag: ns.etag, statement };
+        const statement = ns.exists ? parseOwnershipFile(ns.content, 'agent', { expectedSubAid: record.sub_aid }).statement ?? null : null;
+        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;
@@ -661,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');
@@ -692,10 +1249,14 @@ 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)
+        if (!base || typeof base.raw !== 'string')
             throw ownershipFailure('persistence_unavailable', 'original agent.md evidence is missing');
-        const statement = parseOwnershipFile(ns.content, 'agent', { expectedSubAid: record.sub_aid }).statement ?? null;
+        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)
             throw ownershipFailure('conflict', 'the original ownership statement was replaced');
@@ -705,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 {
@@ -723,7 +1288,29 @@ export class OwnershipWorkflow {
                 continue;
             }
             const action = item.payload.action;
+            if (action === 'owner.ready' && record.legacy_recovery && record.status === 'pending') {
+                const owner = await this.deps.files.readOwner(record.owner_aid, record.sub_aid);
+                if (!owner.exists)
+                    throw ownershipFailure(record.files.owner ? 'conflict' : 'unavailable', 'legacy owner confirmation declaration is missing', !record.files.owner);
+                const file = await this.deps.files.verifyFile(owner.content, 'owner', record.sub_aid, record.owner_aid);
+                if (file.action !== 'declare' || file.statement?.relation_version !== record.target_relation_version || record.files.owner && (record.files.owner.raw !== owner.content || record.files.owner.hash !== owner.sha256))
+                    throw ownershipFailure('conflict', 'legacy owner confirmation declaration changed');
+                if (!record.files.owner)
+                    record.files.owner = { raw: owner.content, hash: owner.sha256, condition: {}, original_owner: { exists: true, raw: owner.content, sha256: owner.sha256 } };
+                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;
@@ -842,8 +1429,10 @@ 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;
                 record.expires_at = task.expires_at;
@@ -853,15 +1442,55 @@ export class OwnershipWorkflow {
             } };
         return task;
     }
+    assertActive(handle) {
+        const current = this.load(handle.record.operation_id);
+        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;
+        await this.upgradeLegacy(handle);
         const record = handle.record;
+        if (!record.base_agent_md && record.request_verified)
+            return;
         if (record.status === 'error' && record.retryable) {
             record.status = 'pending';
             await this.save(handle);
         }
         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)
@@ -898,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);
@@ -907,6 +1536,8 @@ export class OwnershipWorkflow {
             const approved = participants(record).every((name) => record.approvals[name] === 'accept');
             if (record.operation === 'bind' && !approved || record.operation === 'transfer' && this.local() === record.owner_aid && !approved)
                 return;
+            if (record.legacy_recovery && this.local() === record.sub_aid && !record.legacy_recovery.owner_confirmed)
+                return;
             delete record.code;
             delete record.reason;
             record.retryable = true;
@@ -932,11 +1563,17 @@ 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);
             }
             if (this.local() === record.sub_aid) {
+                if (record.legacy_recovery && record.files.owner) {
+                    const current = await this.deps.files.readOwner(record.owner_aid, record.sub_aid), pinned = record.files.owner;
+                    if (!current.exists || current.content !== pinned.raw || current.sha256 !== pinned.hash)
+                        throw ownershipFailure('conflict', 'legacy owner declaration changed before subject publication');
+                }
                 record.step = 'agent';
                 await this.save(handle);
                 await this.deps.files.declareOwneraid(this.fileTask(handle));
@@ -987,7 +1624,7 @@ export class OwnershipWorkflow {
             record.cleanup_status = 'cleaned';
             cleaned = true;
         }
-        const reached = cleaned || result.relation_version === record.target_relation_version && (record.operation === 'release' ? result.status === 'released' && result.lock === 'unlocked' : result.status === 'consensus' && result.owner_aid === targetOwner(record));
+        const reached = cleaned || result.relation_version === (record.operation === 'release' ? record.base_relation_version : record.target_relation_version) && (record.operation === 'release' ? result.status === 'released' && result.lock === 'unlocked' : result.status === 'consensus' && result.owner_aid === targetOwner(record));
         if (!reached)
             return false;
         if (record.operation === 'release' && !cleaned) {
@@ -1027,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') {
@@ -1106,7 +1747,7 @@ export class OwnershipWorkflow {
         }
         await this.deps.files.revokeOwneraid({ operation: 'release', sub_aid: record.sub_aid, owner_aid: targetOwner(record),
             base_relation_version: record.target_relation_version, target_relation_version: observed.relation_version,
-            files: record.release_cleanup.files, expected_agent_statement: original, persist: () => this.save(handle) });
+            files: record.release_cleanup.files, expected_agent_statement: original, assertActive: () => this.assertActive(handle), persist: () => this.save(handle) });
         record.release_cleanup.cleaned = true;
         await this.save(handle);
         this.emit(record, 'ownership.progress');
@@ -1169,8 +1810,8 @@ export class OwnershipWorkflow {
         const payload = { ...ownershipTaskResult(record), local_roles: [...record.local_roles], ...extra };
         if (event === 'ownership.request')
             payload.requester_aid = record.initiator_aid;
-        if (record.verified_relation_version !== undefined)
-            payload.relation_version = record.verified_relation_version;
+        if (record.completion_evidence !== undefined)
+            payload.relation_version = record.completion_evidence.relation_version;
         queueMicrotask(() => { try {
             const pending = this.deps.emit(event, payload);
             if (pending)