@agentunion/fastaun-browser 0.5.20 → 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,7 +89,8 @@ 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 + (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 operation');
     if (message.operation === 'transfer') {
         if (ownershipAid(message.new_owner_aid, 'new_owner_aid') === message.owner_aid)
@@ -148,7 +157,7 @@ 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));
+        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');
@@ -200,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;
     }
@@ -209,11 +218,13 @@ 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)
@@ -229,8 +240,32 @@ 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 && (task.request_validated || Object.keys(task.files).length || task.local_decision !== 'pending'))
+            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))
@@ -275,7 +310,7 @@ export class OwnershipWorkflow {
                     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');
@@ -297,7 +332,7 @@ export class OwnershipWorkflow {
             if (task.status === 'completed') {
                 const consensus = task.verified_consensus;
                 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.target_relation_version || typeof consensus.agent_md_etag !== 'string' || !consensus.agent_md_etag || !/^[0-9a-f]{64}$/.test(consensus.agent_md_sha256))
+                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 (!cleaned && consensus.status !== 'released' || consensus.lock !== 'unlocked' || consensus.owner_aid !== null || task.local_roles.includes('owner') && !task.files.release)
@@ -306,7 +341,7 @@ export class OwnershipWorkflow {
                 else {
                     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');
                 }
             }
@@ -337,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) {
@@ -366,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?.();
@@ -437,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, subAid)).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);
-                        }
-                        catch (error) {
-                            throw failure('persistence_unavailable', `ownership sub lease release failed: ${String(error)}`);
+                        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: [] };
                         }
-                        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);
@@ -478,15 +525,32 @@ 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, subAid) {
+    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.filter((snapshot) => !subAid || typeof snapshot.record.sub_aid !== 'string' || snapshot.record.sub_aid === subAid).map((snapshot) => this.record(snapshot)));
+        return records;
     }
     async observe(subAid) {
         this.requireApplicable(subAid);
@@ -512,8 +576,142 @@ export class OwnershipWorkflow {
             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));
+    }
+    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,
@@ -552,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, subAid)).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 ?? ''))
@@ -569,11 +771,9 @@ 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');
@@ -611,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);
@@ -676,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;
@@ -742,15 +1066,19 @@ export class OwnershipWorkflow {
         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?.();
+            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);
@@ -837,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;
@@ -856,11 +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);
             const cleaned = action === 'sub.cleaned' && task.status === 'completed' && await this.confirmSubCleaned(task);
-            if (!terminal && (notification ? !this.isTarget(task, ns) && !cleaned : !this.isBase(task, ns) || task.status === 'completed' || task.status === 'rejected' || task.status === 'stopped')) {
+            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;
@@ -889,7 +1249,7 @@ export class OwnershipWorkflow {
         let consensus;
         if (task.operation === 'release') {
             consensus = await this.deps.files.checkConsensus(task.sub_aid);
-            if ((cleaned ? consensus.status !== 'unbound' || consensus.relation_version !== 0 : 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 || consensus.agent_md_sha256 !== await ownershipSha256(ns.content))
+            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;
@@ -939,7 +1299,7 @@ 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');
@@ -975,19 +1335,9 @@ export class OwnershipWorkflow {
         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;
-        let history;
-        try {
-            history = await this.storage().listOwnershipTasks(this.deps.currentAid());
-        }
-        catch (error) {
-            throw failure('persistence_unavailable', `ownership cleanup history read failed: ${String(error)}`);
-        }
-        for (const snapshot of history) {
-            if (!['bind', 'transfer'].includes(String(snapshot.record.operation)))
-                continue;
-            if (snapshot.record.sub_aid !== task.sub_aid)
+        for (const candidate of await this.records(this.deps.currentAid(), task.sub_aid, ['bind', 'transfer'])) {
+            if (!['bind', 'transfer'].includes(candidate.operation))
                 continue;
-            const candidate = await this.record(snapshot);
             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;
@@ -1008,14 +1358,7 @@ export class OwnershipWorkflow {
                 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.filter((row) => row.record.sub_aid === task.sub_aid).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;
@@ -1147,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';