@agentunion/fastaun-browser 0.5.18 → 0.5.20

package/dist/ownership-workflow.js

@@ -0,0 +1,1229 @@
+import { isScalar, parseDocument } from 'yaml';
+import { StateError, ValidationError } from './errors.js';
+import { OWNERSHIP_UUID_V4_RE, ownershipAid, ownershipInteger, ownershipSha256, parseOwnershipFile, requireOwnershipApplicable } from './ownership-v21.js';
+export const OWNERSHIP_SDK_MESSAGE_TYPE = 'aun.ownership.sdk.v1';
+export function parseOwnershipRegistrationIntent(raw, aid) {
+    try {
+        const intent = JSON.parse(raw);
+        if (!intent || typeof intent !== 'object' || Array.isArray(intent) || intent.schema_version !== 1 || intent.sub_aid !== aid || typeof intent.type !== 'string' || !intent.type || typeof intent.owner !== 'string' || typeof intent.exttype !== 'string' || typeof intent.pending !== 'boolean')
+            throw new Error('invalid registration intent');
+        const entity = intent.type === 'group' || intent.type === 'org';
+        const keys = ['schema_version', 'sub_aid', 'type', 'owner', 'exttype', 'pending', entity ? 'protocol' : 'operation_id'];
+        if (Object.keys(intent).some((key) => !keys.includes(key)) || keys.some((key) => !Object.hasOwn(intent, key)))
+            throw new Error('invalid registration fields');
+        if (entity ? intent.protocol !== 'entity' || intent.pending || !intent.owner : typeof intent.operation_id !== 'string' || !OWNERSHIP_UUID_V4_RE.test(intent.operation_id))
+            throw new Error('invalid registration protocol');
+        ownershipAid(intent.sub_aid, 'sub_aid');
+        if (intent.owner)
+            ownershipAid(intent.owner, 'owner_aid');
+        if (intent.type === 'human' && intent.owner || intent.type === 'agent' && !intent.owner || intent.pending && !intent.owner)
+            throw new Error('invalid registration owner');
+        return intent;
+    }
+    catch (error) {
+        throw failure('persistence_unavailable', `ownership registration intent is damaged or legacy: ${String(error)}`);
+    }
+}
+function failure(code, reason, retryable = false) {
+    return new StateError(reason, { stringCode: code, retryable });
+}
+function participants(task) {
+    return [...new Set([task.owner_aid, task.sub_aid, ...(task.new_owner_aid ? [task.new_owner_aid] : [])])];
+}
+function targetOwner(task) {
+    return task.operation === 'transfer' ? task.new_owner_aid : task.owner_aid;
+}
+export function isOwnershipSdkPayload(value) {
+    return Boolean(value && typeof value === 'object' && value.type === OWNERSHIP_SDK_MESSAGE_TYPE);
+}
+export function ownershipLocalRoles(value, localAid) {
+    const body = value;
+    const roles = [];
+    if (body?.sub_aid === localAid)
+        roles.push('sub');
+    if (body?.owner_aid === localAid)
+        roles.push('owner');
+    if (body?.new_owner_aid === localAid)
+        roles.push('new_owner');
+    return roles;
+}
+export function parseOwnershipMessage(content) {
+    let value = content;
+    if (typeof content === 'string') {
+        try {
+            value = JSON.parse(content);
+        }
+        catch {
+            throw new ValidationError('ownership message must be JSON');
+        }
+        const document = parseDocument(content, { uniqueKeys: true });
+        if (document.errors.length)
+            throw new ValidationError('ownership message has duplicate or invalid fields');
+        for (const field of ['base_relation_version', 'target_relation_version']) {
+            const node = document.get(field, true);
+            if (!isScalar(node) || !/^(?:0|[1-9][0-9]*)$/.test(node.source ?? ''))
+                throw new ValidationError(`${field} must use an integer`);
+        }
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new ValidationError('ownership message must be an object');
+    const message = value;
+    const required = ['type', 'operation_id', 'operation', 'action', 'sub_aid', 'owner_aid', 'base_relation_version', 'target_relation_version'];
+    const optional = ['new_owner_aid', 'reason'];
+    if (required.some((key) => !Object.hasOwn(message, key)) || Object.keys(message).some((key) => !required.includes(key) && !optional.includes(key)))
+        throw new ValidationError('ownership message contains unknown or missing fields');
+    if (message.type !== OWNERSHIP_SDK_MESSAGE_TYPE)
+        throw failure('unsupported_protocol', 'legacy ownership control is unsupported');
+    if (typeof message.operation_id !== 'string' || !OWNERSHIP_UUID_V4_RE.test(message.operation_id))
+        throw new ValidationError('operation_id must be a UUIDv4');
+    if (!['bind', 'release', 'transfer'].includes(message.operation))
+        throw new ValidationError('ownership operation is invalid');
+    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))
+        throw new ValidationError('ownership target version does not match operation');
+    if (message.operation === 'transfer') {
+        if (ownershipAid(message.new_owner_aid, 'new_owner_aid') === message.owner_aid)
+            throw new ValidationError('transfer target must differ from current owner');
+    }
+    else if ('new_owner_aid' in message)
+        throw new ValidationError('new_owner_aid is only allowed for transfer');
+    const actions = {
+        bind: ['bind.request', 'bind.accept', 'bind.reject', 'owner.ready', 'relation.confirmed', 'operation.stopped'],
+        release: ['relation.confirmed', 'sub.cleaned', 'operation.stopped'],
+        transfer: ['transfer.request', 'transfer.accept', 'transfer.reject', 'transfer.ready', 'owner.ready', 'relation.confirmed', 'operation.stopped'],
+    };
+    if (!actions[message.operation].includes(message.action))
+        throw new ValidationError('ownership action does not match operation');
+    if ('reason' in message && (typeof message.reason !== 'string' || !['bind.reject', 'transfer.reject', 'operation.stopped'].includes(message.action)))
+        throw new ValidationError('ownership reason is only allowed for reject or stopped');
+    return message;
+}
+export function validateOwnershipMessage(message, context) {
+    const from = ownershipAid(context.authenticated_from_aid, 'authenticated_from_aid');
+    const local = ownershipAid(context.local_aid, 'local_aid');
+    if (from === local || !participants(message).includes(from) || !participants(message).includes(local))
+        throw failure('forbidden', 'ownership sender or receiver is not a remote participant');
+    const task = context.task;
+    if (task && ['operation_id', 'operation', 'sub_aid', 'owner_aid', 'new_owner_aid', 'base_relation_version', 'target_relation_version'].some((key) => task[key] !== message[key]))
+        throw failure('conflict', 'ownership fixed task context changed');
+    const initiator = task?.initiator_aid;
+    let direction = false;
+    switch (message.action) {
+        case 'bind.request':
+            direction = (!initiator || from === initiator) && [message.owner_aid, message.sub_aid].includes(from);
+            break;
+        case 'bind.accept':
+        case 'bind.reject':
+            direction = Boolean(initiator && local === initiator && from !== initiator);
+            break;
+        case 'transfer.request':
+        case 'transfer.ready':
+            direction = from === message.owner_aid && [message.sub_aid, message.new_owner_aid].includes(local);
+            break;
+        case 'transfer.accept':
+        case 'transfer.reject':
+            direction = Boolean(task && local === message.owner_aid && [message.sub_aid, message.new_owner_aid].includes(from));
+            break;
+        case 'owner.ready':
+            direction = Boolean(task && from === targetOwner(message) && local === message.sub_aid);
+            break;
+        case 'relation.confirmed':
+            direction = message.operation === 'release' ? from === message.owner_aid && local === message.sub_aid : Boolean(task && from === message.sub_aid && local !== message.sub_aid);
+            break;
+        case 'sub.cleaned':
+            direction = Boolean(task && from === message.sub_aid && local === message.owner_aid);
+            break;
+        case 'operation.stopped':
+            direction = Boolean(task);
+            break;
+    }
+    if (!direction)
+        throw failure('forbidden', 'ownership action has an invalid authenticated direction');
+    if (['owner.ready', 'transfer.ready'].includes(message.action) && task?.local_decision !== 'accept')
+        throw failure('forbidden', 'ownership local approval is required');
+    if (context.ns) {
+        const ns = context.ns;
+        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 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');
+    }
+}
+export function ownershipTaskResult(task) {
+    return {
+        operation_id: task.operation_id, operation: task.operation, sub_aid: task.sub_aid, owner_aid: task.owner_aid,
+        ...(task.new_owner_aid ? { new_owner_aid: task.new_owner_aid } : {}),
+        base_relation_version: task.base_relation_version, target_relation_version: task.target_relation_version,
+        status: task.status, step: task.step,
+        ...(task.code === undefined ? {} : { code: task.code }),
+        ...(task.reason === undefined ? {} : { reason: task.reason }),
+        ...(task.retryable === undefined ? {} : { retryable: task.retryable }),
+    };
+}
+export function ownershipErrorCode(error) {
+    const code = error?.stringCode;
+    if (code && ['owner_locked', 'conflict', 'invalid', 'unavailable', 'not_applicable', 'unsupported_protocol', 'persistence_unavailable', 'forbidden', 'operation_not_found'].includes(code))
+        return code;
+    if (code === 'ownership_conflict')
+        return 'conflict';
+    const numeric = error?.code;
+    if (numeric === -32009)
+        return 'conflict';
+    if (numeric === -32004)
+        return 'forbidden';
+    if (error instanceof ValidationError)
+        return 'invalid';
+    const reason = error instanceof Error ? error.message : String(error);
+    if (reason.includes('owner_locked'))
+        return 'owner_locked';
+    if (/condition conflict|revision conflict|relation version conflict/.test(reason))
+        return 'conflict';
+    return 'unavailable';
+}
+export class OwnershipWorkflow {
+    deps;
+    queues = new Map();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    now() { return Math.trunc(this.deps.now?.() ?? Date.now() / 1000); }
+    requireApplicable(subAid) {
+        if (subAid === this.deps.currentAid())
+            requireOwnershipApplicable(this.deps.currentAidType?.());
+    }
+    storage() {
+        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');
+        }
+        return store;
+    }
+    async load(operationId, aid = this.deps.currentAid()) {
+        try {
+            return await this.storage().loadOwnershipTask(aid, operationId);
+        }
+        catch (error) {
+            throw failure('persistence_unavailable', `ownership task read failed: ${String(error)}`);
+        }
+    }
+    async record(snapshot) {
+        const task = snapshot.record;
+        const localAid = this.deps.currentAid();
+        try {
+            if (!Number.isSafeInteger(snapshot.revision) || snapshot.revision < 1)
+                throw new Error('invalid persisted task revision');
+            if (task.schema_version !== 1 || !['pending', 'completed', 'rejected', 'stopped', 'error'].includes(task.status) || !['pending', 'accept', 'reject'].includes(task.local_decision) || typeof task.step !== 'string')
+                throw new Error('invalid task state');
+            parseOwnershipMessage({ ...this.message(task, task.operation === 'bind' ? 'bind.request' : task.operation === 'transfer' ? 'transfer.request' : 'relation.confirmed') });
+            if (!participants(task).includes(task.initiator_aid) || task.operation !== 'bind' && task.initiator_aid !== task.owner_aid || JSON.stringify(task.local_roles) !== JSON.stringify(ownershipLocalRoles(task, localAid)) || !task.local_roles.length)
+                throw new Error('invalid local task identity');
+            if (!task.approvals || typeof task.approvals !== 'object' || Array.isArray(task.approvals) || Object.entries(task.approvals).some(([aid, decision]) => !participants(task).includes(aid) || !['pending', 'accept', 'reject'].includes(decision)))
+                throw new Error('invalid task approvals');
+            if (JSON.stringify(Object.keys(task.approvals).sort()) !== JSON.stringify(participants(task).sort()) || task.approvals[task.initiator_aid] !== 'accept')
+                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');
+            const base = task.base_agent_md;
+            if (!base && (task.request_validated || Object.keys(task.files).length || task.local_decision !== 'pending'))
+                throw new Error('missing original agent.md context');
+            if (base) {
+                if (typeof base.exists !== 'boolean' || typeof base.raw !== 'string' || typeof base.etag !== 'string' || base.exists && !base.etag || base.sha256 !== await ownershipSha256(base.raw))
+                    throw new Error('invalid original agent.md bytes or ETag');
+                const statement = base.exists ? parseOwnershipFile(base.raw, 'agent', { expectedSubAid: task.sub_aid }).statement : undefined;
+                if ((statement?.relation_version ?? 0) !== task.base_relation_version || statement && task.operation !== 'bind' && statement.owner_aid !== task.owner_aid || (statement ? !this.sameStatement(statement, base.statement ?? undefined) : base.statement !== null))
+                    throw new Error('invalid original agent.md statement');
+            }
+            if (task.base_owner_md) {
+                const prior = task.base_owner_md;
+                if (typeof prior.exists !== 'boolean' || typeof prior.raw !== 'string' || prior.sha256 !== (prior.exists ? await ownershipSha256(prior.raw) : '') || !prior.exists && prior.raw !== '')
+                    throw new Error('invalid original owner.md context');
+                if (base?.statement && !prior.exists && (task.operation === 'transfer' || task.operation === 'release' && task.local_roles.includes('owner')))
+                    throw new Error('missing original owner.md relation');
+                if (prior.exists) {
+                    const file = parseOwnershipFile(prior.raw, 'owner', { expectedSubAid: task.sub_aid });
+                    if (!file.statement || file.statement.owner_aid !== base?.statement?.owner_aid || file.statement.relation_version !== base?.statement?.relation_version)
+                        throw new Error('invalid original owner.md statement');
+                }
+            }
+            if (base?.statement && !task.base_owner_md && !(task.operation === 'release' && task.local_roles.includes('sub') && !task.local_roles.includes('owner') && task.cleanup_authorization_operation_id && !task.files.cleanup))
+                throw new Error('missing original owner.md context');
+            if (task.approvals[localAid] !== task.local_decision)
+                throw new Error('task decision and approval differ');
+            if (task.status === 'completed' && (task.verified_relation_version !== task.target_relation_version || task.operation !== 'release' && task.local_decision !== 'accept'))
+                throw new Error('invalid completion evidence or local approval');
+            const transferEvidenceRequired = task.operation === 'transfer' && task.local_roles.some((role) => role === 'sub' || role === 'new_owner') && (task.status === 'completed' || this.ongoing(task) && (Boolean(task.files.owner || task.files.agent || task.hints['transfer.ready']) || task.authorization_sha256 !== undefined));
+            const expiresAt = task.expires_at;
+            if (transferEvidenceRequired && (!/^[0-9a-f]{64}$/.test(task.authorization_sha256 ?? '') || typeof expiresAt !== 'number' || !Number.isSafeInteger(expiresAt) || expiresAt <= 0))
+                throw new Error('invalid transfer authorization evidence');
+            for (const [key, prepared] of Object.entries(task.files)) {
+                const agentFile = key === 'agent' || key === 'cleanup';
+                if (!['agent', 'owner', 'release', 'transfer', 'cleanup'].includes(key) || !prepared || typeof prepared.raw !== 'string' || !/^[0-9a-f]{64}$/.test(prepared.sha256) || await ownershipSha256(prepared.raw) !== prepared.sha256 || !prepared.condition || typeof prepared.condition !== 'object' || Array.isArray(prepared.condition))
+                    throw new Error('invalid prepared file bytes');
+                const condition = prepared.condition;
+                if (agentFile ? Object.keys(condition).length !== 1 || !(typeof condition.if_match === 'string' && condition.if_match || condition.if_none_match === '*') : Object.keys(condition).length !== 0)
+                    throw new Error('invalid prepared file condition');
+                const original = prepared.original_owner;
+                if (!agentFile && (!original || typeof original.exists !== 'boolean' || typeof original.raw !== 'string' || original.sha256 !== (original.exists ? await ownershipSha256(original.raw) : '') || !original.exists && original.raw !== ''))
+                    throw new Error('invalid prepared owner original');
+                if (key === 'cleanup' && task.operation !== 'release' || key === 'release' && task.operation !== 'release' || key === 'transfer' && task.operation !== 'transfer' || ['agent', 'owner'].includes(key) && task.operation === 'release')
+                    throw new Error('invalid prepared file operation');
+                const ownerAid = key === 'owner' || key === 'agent' ? targetOwner(task) : task.owner_aid;
+                const file = parseOwnershipFile(prepared.raw, agentFile ? 'agent' : 'owner', { expectedSubAid: task.sub_aid, expectedOwnerAid: key === 'cleanup' ? undefined : ownerAid });
+                if (!task.local_roles.includes(agentFile ? 'sub' : key === 'owner' && task.operation === 'transfer' ? 'new_owner' : 'owner'))
+                    throw new Error('invalid prepared file local role');
+                if (key === 'cleanup' ? Boolean(file.statement) : file.statement?.relation_version !== (key === 'owner' || key === 'agent' ? task.target_relation_version : task.base_relation_version))
+                    throw new Error('invalid prepared file generation');
+                const fileExpiry = prepared.expires_at;
+                if (!agentFile && file.action !== (key === 'owner' ? 'declare' : key === 'release' ? 'release' : 'transfer_owner') || key === 'transfer' && (typeof fileExpiry !== 'number' || !Number.isSafeInteger(fileExpiry) || fileExpiry <= 0 || fileExpiry !== task.expires_at || file.transfer?.new_owner_aid !== task.new_owner_aid || file.transfer?.target_relation_version !== task.target_relation_version || file.transfer?.expires_at !== fileExpiry) || key !== 'transfer' && fileExpiry !== undefined)
+                    throw new Error('invalid prepared file authorization');
+                if (prepared.published_etag !== undefined && (!agentFile || typeof prepared.published_etag !== 'string' || !prepared.published_etag) || prepared.cleaned !== undefined && typeof prepared.cleaned !== 'boolean')
+                    throw new Error('invalid prepared file result');
+            }
+            if (task.release_cleanup !== undefined) {
+                const cleanup = task.release_cleanup;
+                if (!['bind', 'transfer'].includes(task.operation) || task.status !== 'completed' || !task.local_roles.includes('sub') || task.local_decision !== 'accept' || typeof cleanup.cleaned !== 'boolean' || !cleanup.files || typeof cleanup.files !== 'object' || Array.isArray(cleanup.files))
+                    throw new Error('invalid historical cleanup context');
+                for (const [key, prepared] of Object.entries(cleanup.files)) {
+                    if (key !== 'cleanup' || !prepared || prepared.sha256 !== await ownershipSha256(prepared.raw) || typeof prepared.condition?.if_match !== 'string' || !prepared.condition.if_match || Object.keys(prepared.condition).length !== 1 || parseOwnershipFile(prepared.raw, 'agent', { expectedSubAid: task.sub_aid }).statement)
+                        throw new Error('invalid historical cleanup original file');
+                }
+            }
+            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))
+                    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)
+                        throw new Error('invalid persisted release evidence');
+                }
+                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)
+                        throw new Error('persisted consensus differs from local original files');
+                }
+            }
+            for (const key of task.received) {
+                if (typeof key !== 'string' || key.split('|').length !== 2)
+                    throw new Error('invalid received journal');
+                const [fromAid, action] = key.split('|');
+                const message = parseOwnershipMessage(this.message(task, action));
+                validateOwnershipMessage(message, { authenticated_from_aid: fromAid, local_aid: localAid, task });
+            }
+            for (const item of task.inbox) {
+                parseOwnershipMessage(item.payload);
+                validateOwnershipMessage(item.payload, { authenticated_from_aid: item.from_aid, local_aid: localAid, task });
+                if (!task.received.includes(item.from_aid + '|' + item.payload.action))
+                    throw new Error('invalid inbox journal');
+            }
+            for (const item of task.outbox) {
+                parseOwnershipMessage(item.payload);
+                const action = item.payload.action;
+                if (['bind.accept', 'transfer.accept', 'owner.ready', 'transfer.ready'].includes(action) && task.local_decision !== 'accept' || ['bind.reject', 'transfer.reject'].includes(action) && task.local_decision !== 'reject')
+                    throw new Error('invalid outbox local approval');
+                if (['bind.accept', 'transfer.accept', 'bind.reject', 'transfer.reject'].includes(action) && !task.request_validated)
+                    throw new Error('invalid outbox received request');
+                validateOwnershipMessage(item.payload, { authenticated_from_aid: localAid, local_aid: item.to_aid, task });
+                if (item.key !== `${item.to_aid}|${item.payload.action}` || typeof item.message_id !== 'string' || !/^m-[0-9a-f]{32}$/.test(item.message_id))
+                    throw new Error('invalid outbox target');
+            }
+            return task;
+        }
+        catch (error) {
+            throw failure('persistence_unavailable', `ownership task is damaged: ${String(error)}`);
+        }
+    }
+    message(task, action, reason) {
+        return { type: OWNERSHIP_SDK_MESSAGE_TYPE, operation_id: task.operation_id, operation: task.operation, action,
+            sub_aid: task.sub_aid, owner_aid: task.owner_aid, ...(task.new_owner_aid ? { new_owner_aid: task.new_owner_aid } : {}),
+            base_relation_version: task.base_relation_version, target_relation_version: task.target_relation_version,
+            ...(reason === undefined ? {} : { reason }) };
+    }
+    create(message, initiator, localDecision) {
+        const aid = this.deps.currentAid();
+        return { schema_version: 1, operation_id: message.operation_id, operation: message.operation,
+            sub_aid: message.sub_aid, owner_aid: message.owner_aid, ...(message.new_owner_aid ? { new_owner_aid: message.new_owner_aid } : {}),
+            base_relation_version: message.base_relation_version, target_relation_version: message.target_relation_version,
+            status: 'pending', step: 'created', retryable: true, initiator_aid: initiator, local_roles: ownershipLocalRoles(message, aid),
+            local_decision: localDecision, approvals: { ...Object.fromEntries(participants(message).map((participant) => [participant, 'pending'])), [initiator]: 'accept', ...(localDecision === 'pending' ? {} : { [aid]: localDecision }) },
+            files: {}, inbox: [], received: [], outbox: [], sent: [], hints: {}, created_at: this.now(), request_validated: initiator === aid };
+    }
+    enqueue(task, toAid, action, reason) {
+        if (toAid === this.deps.currentAid())
+            return;
+        const key = `${toAid}|${action}`;
+        if (task.sent.includes(key) || task.outbox.some((item) => item.key === key))
+            return;
+        task.outbox.push({ key, to_aid: toAid, message_id: `m-${crypto.randomUUID().replace(/-/g, '')}`, payload: this.message(task, action, reason) });
+    }
+    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 } });
+    }
+    async save(context) {
+        context.guard?.();
+        if (context.aid !== this.deps.currentAid())
+            throw failure('forbidden', 'ownership current identity changed');
+        const store = this.storage();
+        let renewed;
+        try {
+            renewed = await store.renewOwnershipTaskLease(context.aid, context.lease, this.now() + 60);
+        }
+        catch (error) {
+            throw failure('persistence_unavailable', `ownership lease check failed: ${String(error)}`);
+        }
+        if (!renewed)
+            throw failure('persistence_unavailable', 'ownership sub lease or fencing was lost');
+        context.lease = renewed;
+        let saved;
+        try {
+            saved = await store.compareAndSwapOwnershipTask(context.aid, context.task.operation_id, context.revision, context.task, renewed);
+        }
+        catch (error) {
+            throw failure('persistence_unavailable', `ownership task save failed: ${String(error)}`);
+        }
+        if (!saved)
+            throw failure('persistence_unavailable', 'ownership task revision conflict');
+        context.revision = saved.revision;
+        if (context.aid !== this.deps.currentAid())
+            throw failure('forbidden', 'ownership current identity changed');
+        context.guard?.();
+    }
+    async queued(subAid, work, guard) {
+        const aid = this.deps.currentAid(), events = [];
+        const previous = this.queues.get(subAid) ?? Promise.resolve();
+        const queued = previous.catch(() => { }).then(() => work(events));
+        this.queues.set(subAid, queued);
+        const cleanup = () => { if (this.queues.get(subAid) === queued)
+            this.queues.delete(subAid); };
+        queued.then(cleanup, cleanup);
+        const result = await queued;
+        guard?.();
+        if (aid !== this.deps.currentAid())
+            throw failure('forbidden', 'ownership current identity changed');
+        for (const event of events)
+            await this.deps.emit(event.event, event.payload);
+        return result;
+    }
+    async execute(subAid, operationId, initial, mutate, guard) {
+        return await this.queued(subAid, (events) => this.advance(subAid, operationId, initial, events, mutate, guard), guard);
+    }
+    async advance(subAid, operationId, initial, events, mutate, guard) {
+        const store = this.storage(), aid = this.deps.currentAid();
+        const output = await (async () => {
+            guard?.();
+            if (aid !== this.deps.currentAid())
+                throw failure('forbidden', 'ownership current identity changed');
+            let lease;
+            try {
+                lease = await store.acquireOwnershipTaskLease(aid, subAid, operationId, crypto.randomUUID(), this.now() + 60);
+            }
+            catch (error) {
+                throw failure('persistence_unavailable', `ownership sub lease failed: ${String(error)}`);
+            }
+            if (!lease)
+                throw failure('persistence_unavailable', 'ownership sub is being advanced by another instance');
+            let context;
+            try {
+                const saved = await this.load(operationId, aid);
+                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));
+                    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)}`);
+                        }
+                        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)
+                    await this.save(context);
+                await mutate?.(context);
+                await this.drive(context);
+                return { result: ownershipTaskResult(context.task), events: context.events };
+            }
+            finally {
+                try {
+                    await store.releaseOwnershipTaskLease(aid, context?.lease ?? lease);
+                }
+                catch (error) {
+                    throw failure('persistence_unavailable', `ownership sub lease release failed: ${String(error)}`);
+                }
+            }
+        })();
+        guard?.();
+        if (aid !== this.deps.currentAid())
+            throw failure('forbidden', 'ownership current identity changed');
+        events.push(...output.events);
+        return output.result;
+    }
+    ongoing(task) { return task.status === 'pending' || task.status === 'error' && task.retryable === true; }
+    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) {
+        let snapshots;
+        try {
+            snapshots = await this.storage().listOwnershipTasks(aid);
+        }
+        catch (error) {
+            throw failure('persistence_unavailable', `ownership task list failed: ${String(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)));
+    }
+    async observe(subAid) {
+        this.requireApplicable(subAid);
+        const snapshot = await this.deps.files.readAgent(subAid);
+        const file = snapshot.exists ? await this.deps.files.verify(snapshot.content, 'agent', subAid) : null;
+        if (file)
+            requireOwnershipApplicable(file.frontmatter.type);
+        if ((file?.statement?.relation_version ?? 0) !== snapshot.relation_version)
+            throw failure('unavailable', 'NS relation metadata does not match agent.md', true);
+        if (snapshot.lock === 'locked' && (!file?.statement || file.statement.relation_version !== snapshot.relation_version || snapshot.owner_aid !== undefined && snapshot.owner_aid !== file.statement.owner_aid))
+            throw failure('unavailable', 'NS lock and current signed agent.md differ', true);
+        return { ...snapshot, file, owner_aid: snapshot.lock === 'locked' ? file.statement.owner_aid : null };
+    }
+    isBase(task, ns) {
+        const base = task.base_agent_md;
+        return ns.relation_version === task.base_relation_version && (task.operation === 'bind' ? ns.lock === 'unlocked' : ns.lock === 'locked' && ns.owner_aid === task.owner_aid) && (!base || base.exists === ns.exists && (base.statement ? this.sameStatement(base.statement, ns.file?.statement) : !ns.file?.statement && base.raw === ns.content && base.etag === ns.etag));
+    }
+    async captureBase(task, ns) {
+        if (!task.base_agent_md)
+            task.base_agent_md = { exists: ns.exists, raw: ns.content, sha256: await ownershipSha256(ns.content), etag: ns.etag, statement: ns.file?.statement ?? null };
+        if (!task.base_owner_md) {
+            const prior = ns.file?.statement ? await this.deps.files.readOwner(ns.file.statement.owner_aid, task.sub_aid) : null;
+            task.base_owner_md = prior ? { exists: prior.exists, raw: prior.content, sha256: prior.sha256 } : { exists: false, raw: '', sha256: '' };
+        }
+    }
+    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));
+    }
+    fileTask(context, expectedStatement) {
+        const task = { ...context.task, files: context.task.files, expected_agent_statement: expectedStatement,
+            persist: async () => { context.task.expires_at = task.expires_at; context.task.authorization_sha256 = task.authorization_sha256; context.task.base_agent_md = task.base_agent_md; context.task.base_owner_md = task.base_owner_md; await this.save(context); },
+            guard: async () => { context.task.expires_at = task.expires_at; context.task.authorization_sha256 = task.authorization_sha256; context.task.base_agent_md = task.base_agent_md; context.task.base_owner_md = task.base_owner_md; await this.save(context); } };
+        return task;
+    }
+    async start(operation, subAid, ownerAid, newOwnerAid, requestedId, guard) {
+        this.requireApplicable(subAid);
+        const aid = this.deps.currentAid();
+        return await this.queued(subAid, async (events) => {
+            if (aid !== this.deps.currentAid())
+                throw failure('forbidden', 'ownership current identity changed');
+            return await this.startCurrent(operation, subAid, ownerAid, events, newOwnerAid, requestedId, guard);
+        }, guard);
+    }
+    async startCurrent(operation, subAid, ownerAid, events, newOwnerAid, requestedId, guard) {
+        guard?.();
+        this.storage();
+        const aid = ownershipAid(this.deps.currentAid(), 'local_aid');
+        ownershipAid(subAid, 'sub_aid');
+        ownershipAid(ownerAid, 'owner_aid');
+        if (newOwnerAid)
+            ownershipAid(newOwnerAid, 'new_owner_aid');
+        if (operation === 'transfer' && (!newOwnerAid || newOwnerAid === ownerAid))
+            throw failure('invalid', 'ownership transfer target must differ from current owner');
+        if (requestedId) {
+            if (!OWNERSHIP_UUID_V4_RE.test(requestedId))
+                throw failure('invalid', 'ownership registration operation_id must be a UUIDv4');
+            const saved = await this.load(requestedId);
+            if (saved) {
+                const task = await this.record(saved);
+                if (task.operation !== operation || task.sub_aid !== subAid || task.owner_aid !== ownerAid || task.new_owner_aid !== newOwnerAid || task.initiator_aid !== aid)
+                    throw failure('conflict', 'ownership registration intent changed');
+                return await this.advance(subAid, requestedId, undefined, events, undefined, guard);
+            }
+        }
+        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 (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 ?? ''))
+                    return result;
+            }
+            else {
+                const current = await this.observe(subAid);
+                if (this.isBase(pending, current))
+                    throw failure('conflict', 'another local operation for this sub is pending');
+                const result = await this.advance(subAid, pending.operation_id, undefined, events, undefined, guard);
+                if (result.status === 'pending' || result.status === 'error')
+                    throw failure('conflict', 'another local operation for this sub is pending');
+            }
+        }
+        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')
+                throw failure('invalid', 'human cannot declare an owner');
+            if (ns.file?.statement?.owner_aid === ownerAid)
+                throw failure('conflict', 'current owner release requires sub cleanup before binding again');
+        }
+        else {
+            if (aid !== ownerAid || ns.lock !== 'locked' || ns.owner_aid !== aid)
+                throw failure('forbidden', 'only the current original owner may release or transfer');
+            const consensus = await this.deps.files.checkConsensus(subAid);
+            if (consensus.status !== 'consensus' || consensus.owner_aid !== aid || consensus.relation_version !== ns.relation_version)
+                throw failure(consensus.status === 'invalid' ? 'invalid' : 'unavailable', 'the current owner relation could not be verified', consensus.status !== 'invalid');
+        }
+        const targetVersion = ownershipInteger(ns.relation_version + (operation === 'release' ? 0 : 1), 'target_relation_version');
+        const operationId = requestedId ?? crypto.randomUUID();
+        const payload = { type: OWNERSHIP_SDK_MESSAGE_TYPE, operation_id: operationId, operation, action: operation === 'bind' ? 'bind.request' : operation === 'transfer' ? 'transfer.request' : 'relation.confirmed', sub_aid: subAid, owner_aid: ownerAid, ...(newOwnerAid ? { new_owner_aid: newOwnerAid } : {}), base_relation_version: ns.relation_version, target_relation_version: targetVersion };
+        const task = this.create(payload, aid, 'accept');
+        await this.captureBase(task, ns);
+        if (!task.local_roles.length)
+            throw failure('forbidden', 'the local AID is not an ownership participant');
+        if (aid !== this.deps.currentAid())
+            throw failure('forbidden', 'ownership current identity changed');
+        return await this.advance(subAid, operationId, task, events, async (context) => {
+            if (context.revision === 1) {
+                if (operation === 'bind')
+                    for (const peer of participants(task))
+                        this.enqueue(context.task, peer, 'bind.request');
+                if (operation === 'transfer')
+                    for (const peer of [...new Set([subAid, newOwnerAid])])
+                        this.enqueue(context.task, peer, 'transfer.request');
+                await this.save(context);
+            }
+        }, guard);
+    }
+    async bindOwneraid(ownerAid) { return await this.start('bind', this.deps.currentAid(), ownerAid); }
+    async bindSubaid(subAid) { return await this.start('bind', subAid, this.deps.currentAid()); }
+    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 checkOwnershipConsensus(subAid = this.deps.currentAid()) { return await this.deps.files.checkConsensus(subAid); }
+    async decide(operationId, decision, reason) {
+        const saved = await this.load(operationId);
+        if (!saved)
+            throw failure('operation_not_found', 'ownership operation was not found');
+        const original = await this.record(saved);
+        return await this.execute(original.sub_aid, operationId, undefined, async (context) => {
+            const task = context.task;
+            if (task.operation === 'release' || task.initiator_aid === context.aid || !task.request_validated)
+                throw failure(task.request_validated ? 'forbidden' : 'unavailable', 'ownership approval requires a verified local received request');
+            if (task.local_decision !== 'pending') {
+                if (task.local_decision !== decision)
+                    throw failure('conflict', 'ownership approval decision is immutable');
+                return;
+            }
+            if (['completed', 'rejected', 'stopped'].includes(task.status) || task.status === 'error' && !task.retryable)
+                throw failure('conflict', 'ownership operation no longer awaits approval');
+            const ns = await this.observe(task.sub_aid);
+            if (!this.isBase(task, ns))
+                throw failure(ns.lock === 'locked' && task.operation === 'bind' ? 'owner_locked' : 'conflict', 'ownership approval current relation changed');
+            task.local_decision = decision;
+            task.approvals[context.aid] = decision;
+            task.step = decision === 'accept' ? 'approved' : 'rejected';
+            if (decision === 'reject') {
+                task.status = 'rejected';
+                task.reason = reason;
+                task.retryable = false;
+            }
+            this.enqueue(task, task.initiator_aid, task.operation === 'bind' ? decision === 'accept' ? 'bind.accept' : 'bind.reject' : decision === 'accept' ? 'transfer.accept' : 'transfer.reject', reason);
+            await this.save(context);
+            this.event(context, decision === 'reject' ? 'ownership.rejected' : 'ownership.progress');
+        });
+    }
+    async acceptOwnershipRequest(operationId) { return await this.decide(operationId, 'accept'); }
+    async rejectOwnershipRequest(operationId, reason) { return await this.decide(operationId, 'reject', reason); }
+    async receive(fromAid, content) {
+        let body = content;
+        if (typeof content === 'string') {
+            try {
+                body = JSON.parse(content);
+            }
+            catch {
+                return false;
+            }
+        }
+        if (!isOwnershipSdkPayload(body)) {
+            const type = body && typeof body === 'object' ? body.type : undefined;
+            return typeof type === 'string' && (type === 'aun.ownership.v1' || type.startsWith('aun.ownership.'));
+        }
+        let message;
+        try {
+            message = parseOwnershipMessage(content);
+        }
+        catch {
+            return true;
+        }
+        try {
+            this.requireApplicable(message.sub_aid);
+        }
+        catch (error) {
+            if (ownershipErrorCode(error) === 'not_applicable')
+                return true;
+            throw error;
+        }
+        const snapshot = await this.load(message.operation_id);
+        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;
+        const initial = prior ?? this.create(message, fromAid, 'pending');
+        try {
+            validateOwnershipMessage(message, { authenticated_from_aid: fromAid, local_aid: this.deps.currentAid(), task: initial });
+        }
+        catch {
+            return true;
+        }
+        let observationError;
+        try {
+            await this.deps.files.readAgent(message.sub_aid);
+        }
+        catch (error) {
+            if (ownershipErrorCode(error) === 'not_applicable')
+                return true;
+            observationError = error;
+        }
+        await this.execute(message.sub_aid, message.operation_id, initial, async (context) => {
+            context.observationError = observationError;
+            try {
+                validateOwnershipMessage(message, { authenticated_from_aid: fromAid, local_aid: context.aid, task: context.task });
+            }
+            catch {
+                return;
+            }
+            if (message.action === 'sub.cleaned' && !await this.confirmSubCleaned(context.task))
+                return;
+            const key = `${fromAid}|${message.action}`;
+            if (!context.task.received.includes(key)) {
+                context.task.received.push(key);
+                context.task.inbox.push({ from_aid: fromAid, payload: message });
+                await this.save(context);
+            }
+        });
+        return true;
+    }
+    async confirmSubCleaned(task) {
+        const began = this.now(), before = await this.deps.files.readAgent(task.sub_aid);
+        if (!before.exists || before.relation_version !== 0 || before.lock !== 'unlocked' || before.owner_aid || !before.etag)
+            return false;
+        const file = parseOwnershipFile(before.content, 'agent', { expectedSubAid: task.sub_aid });
+        if (Object.hasOwn(file.frontmatter, 'owner') || Object.hasOwn(file.frontmatter, 'ownership'))
+            return false;
+        if (!task.base_agent_md?.statement || task.base_agent_md.statement.owner_aid !== task.owner_aid || task.base_agent_md.statement.sub_aid !== task.sub_aid || task.base_agent_md.statement.relation_version !== task.base_relation_version)
+            return false;
+        let ownerHash = '';
+        if (task.local_roles.includes('owner') && task.files.release) {
+            const original = task.files.release, object = await this.deps.files.readOwner(task.owner_aid, task.sub_aid);
+            if (object.exists && object.content === original.raw && object.sha256 === original.sha256) {
+                const file = await this.deps.files.verify(object.content, 'owner', task.sub_aid, task.owner_aid);
+                if (file.action === 'release' && file.statement && ['version', 'owner_aid', 'sub_aid', 'relation_version'].every((key) => file.statement[key] === task.base_agent_md.statement[key]))
+                    ownerHash = object.sha256;
+            }
+        }
+        const confirmed = Boolean(await this.cleanupEvidence(task, { agent_md_etag: before.etag, agent_md_sha256: await ownershipSha256(before.content), owner_md_sha256: ownerHash }, before.content));
+        const after = await this.deps.files.readAgent(task.sub_aid);
+        if (this.now() - began > 30 || before.exists !== after.exists || before.etag !== after.etag || before.relation_version !== after.relation_version || before.lock !== after.lock || before.owner_aid !== after.owner_aid || before.content !== after.content)
+            throw failure('unavailable', 'NS changed during sub cleanup verification', true);
+        return confirmed;
+    }
+    async resume(guard) {
+        guard?.();
+        let snapshots;
+        try {
+            snapshots = await this.storage().listOwnershipTasks(this.deps.currentAid());
+        }
+        catch (error) {
+            throw failure('persistence_unavailable', `ownership task list failed: ${String(error)}`);
+        }
+        for (const snapshot of snapshots) {
+            guard?.();
+            try {
+                const task = await this.record(snapshot);
+                if (['rejected', 'stopped'].includes(task.status) && !task.outbox.length && !task.inbox.length || task.status === 'completed' && !task.cleanup_pending && !task.outbox.length && !task.inbox.length && !(['bind', 'transfer'].includes(task.operation) && task.local_roles.includes('sub') && task.local_decision === 'accept' && !task.release_cleanup?.cleaned))
+                    continue;
+                await this.execute(task.sub_aid, task.operation_id, undefined, undefined, guard);
+            }
+            catch (error) {
+                guard?.();
+                if (ownershipErrorCode(error) !== 'conflict')
+                    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 });
+            }
+        }
+    }
+    async inbox(context) {
+        const task = context.task;
+        while (task.inbox.length) {
+            if (task.status === 'error' && !task.retryable) {
+                task.inbox.shift();
+                await this.save(context);
+                continue;
+            }
+            const entry = task.inbox[0];
+            const ns = await this.observe(task.sub_aid);
+            if (!task.base_agent_md && !task.request_validated && task.local_decision === 'pending' && !Object.keys(task.files).length) {
+                if (this.isBase(task, ns) || task.operation === 'release' && ns.relation_version === task.base_relation_version && ns.file?.statement?.owner_aid === task.owner_aid)
+                    await this.captureBase(task, ns);
+                else if (task.operation === 'release' && ns.relation_version === 0 && !ns.file?.statement && task.local_roles.includes('sub')) {
+                    for (const candidate of await this.records(context.aid, task.sub_aid)) {
+                        const original = candidate.files.agent, cleanup = candidate.release_cleanup?.files.cleanup;
+                        if (!['bind', 'transfer'].includes(candidate.operation) || candidate.local_decision !== 'accept' || !candidate.local_roles.includes('sub') || targetOwner(candidate) !== task.owner_aid || candidate.target_relation_version !== task.base_relation_version || !original || !cleanup || cleanup.raw !== ns.content || cleanup.sha256 !== await ownershipSha256(ns.content) || cleanup.published_etag !== undefined && cleanup.published_etag !== ns.etag)
+                            continue;
+                        const statement = parseOwnershipFile(original.raw, 'agent', { expectedSubAid: task.sub_aid }).statement;
+                        if (!statement || !cleanup.condition?.if_match)
+                            continue;
+                        task.base_agent_md = { exists: true, raw: original.raw, sha256: original.sha256, etag: cleanup.condition.if_match, statement };
+                        task.cleanup_authorization_operation_id = candidate.operation_id;
+                        break;
+                    }
+                }
+                if (task.base_agent_md)
+                    await this.save(context);
+            }
+            try {
+                validateOwnershipMessage(entry.payload, { authenticated_from_aid: entry.from_aid, local_aid: context.aid, task, ns });
+            }
+            catch {
+                task.inbox.shift();
+                task.received.push(entry.from_aid + '|' + entry.payload.action);
+                await this.save(context);
+                continue;
+            }
+            const action = entry.payload.action;
+            if (!['rejected', 'stopped', 'completed'].includes(task.status) && !(task.status === 'error' && !task.retryable)) {
+                if (action === 'bind.request' || action === 'transfer.request') {
+                    task.request_validated = true;
+                }
+                else if (['bind.accept', 'transfer.accept', 'bind.reject', 'transfer.reject'].includes(action)) {
+                    const decision = action.endsWith('.accept') ? 'accept' : 'reject';
+                    if (decision === 'reject' && await this.complete(context, ns)) {
+                        task.inbox.shift();
+                        await this.save(context);
+                        continue;
+                    }
+                    if (!task.approvals[entry.from_aid] || task.approvals[entry.from_aid] === 'pending') {
+                        task.approvals[entry.from_aid] = decision;
+                        if (decision === 'reject') {
+                            task.status = 'rejected';
+                            task.step = 'rejected';
+                            task.reason = entry.payload.reason;
+                            task.retryable = false;
+                            if (task.operation === 'transfer')
+                                for (const peer of participants(task))
+                                    if (peer !== entry.from_aid)
+                                        this.enqueue(task, peer, 'operation.stopped', entry.payload.reason);
+                            this.event(context, 'ownership.rejected');
+                        }
+                    }
+                }
+                else if (action === 'operation.stopped') {
+                    if (!await this.complete(context, ns)) {
+                        task.status = 'stopped';
+                        task.step = 'stopped';
+                        task.reason = entry.payload.reason;
+                        task.retryable = false;
+                        this.event(context, 'ownership.stopped');
+                    }
+                }
+                else {
+                    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;
+                    }
+                    task.hints[action] = true;
+                }
+            }
+            else if (action === 'sub.cleaned') {
+                const file = ns.file;
+                if (ns.relation_version === 0 && ns.lock === 'unlocked' && !ns.owner_aid && file && !file.statement && !Object.hasOwn(file.frontmatter, 'owner') && !Object.hasOwn(file.frontmatter, 'ownership'))
+                    task.hints[action] = true;
+            }
+            task.inbox.shift();
+            await this.save(context);
+        }
+    }
+    async flush(context, ns) {
+        const task = context.task;
+        for (const item of [...task.outbox]) {
+            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')) {
+                task.outbox = task.outbox.filter((row) => row.key !== item.key);
+                await this.save(context);
+                continue;
+            }
+            if (action === 'owner.ready' || action === 'transfer.ready') {
+                const prepared = task.files[action === 'owner.ready' ? 'owner' : 'transfer'];
+                const object = await this.deps.files.readOwner(action === 'owner.ready' ? targetOwner(task) : task.owner_aid, task.sub_aid);
+                if (!prepared || !object.exists || object.sha256 !== prepared.sha256 || object.content !== prepared.raw)
+                    throw failure('conflict', 'ownership ready file has been replaced');
+                const fileExpiry = prepared.expires_at;
+                if (action === 'transfer.ready' && (typeof fileExpiry !== 'number' || !Number.isSafeInteger(fileExpiry) || fileExpiry <= 0 || fileExpiry !== task.expires_at || fileExpiry <= this.now()))
+                    throw failure('conflict', 'ownership transfer authorization expired');
+            }
+            await this.save(context);
+            await this.deps.send(item.to_aid, item.payload, item.message_id);
+            task.outbox = task.outbox.filter((row) => row.key !== item.key);
+            task.sent.push(item.key);
+            await this.save(context);
+        }
+    }
+    async complete(context, ns) {
+        const task = context.task;
+        const began = Date.now(), cleaned = task.operation === 'release' && ns.exists && ns.relation_version === 0 && ns.lock === 'unlocked' && !ns.file?.statement;
+        if (!this.isTarget(task, ns) && !cleaned)
+            return false;
+        let consensus;
+        if (task.operation === 'release') {
+            consensus = await this.deps.files.checkConsensus(task.sub_aid);
+            if ((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))
+                throw failure(consensus.status === 'invalid' ? 'invalid' : 'unavailable', 'ownership release could not be freshly confirmed', consensus.status !== 'invalid');
+            if (!cleaned && task.files.release && consensus.owner_md_sha256) {
+                const source = task.files.release;
+                if (source.sha256 !== consensus.owner_md_sha256)
+                    throw failure('conflict', 'current release material does not belong to this task');
+            }
+            if (cleaned) {
+                const source = task.files.release;
+                if (task.local_roles.includes('owner') && source) {
+                    const object = await this.deps.files.readOwner(task.owner_aid, task.sub_aid);
+                    if (object.exists && object.content === source.raw && object.sha256 === source.sha256) {
+                        await this.deps.files.verify(object.content, 'owner', task.sub_aid, task.owner_aid);
+                        consensus.owner_md_sha256 = object.sha256;
+                    }
+                }
+                const authorization = await this.cleanupEvidence(task, consensus, ns.content);
+                if (!authorization)
+                    throw failure('conflict', 'no local cleanup original can confirm this release task');
+                const after = await this.observe(task.sub_aid);
+                if (Date.now() - began > 30_000 || after.etag !== ns.etag || after.content !== ns.content || !after.exists || after.relation_version !== 0 || after.lock !== 'unlocked' || after.owner_aid)
+                    throw failure('unavailable', 'NS changed during cleanup confirmation', true);
+                if (authorization !== task.operation_id)
+                    task.cleanup_authorization_operation_id = authorization;
+            }
+            const prior = ns.file?.statement;
+            if (prior && (prior.owner_aid !== task.owner_aid || prior.relation_version !== task.base_relation_version || !this.sameStatement(prior, task.base_agent_md?.statement ?? undefined)))
+                throw failure('conflict', 'ownership released document does not match this generation');
+            if (task.local_roles.includes('owner') && !task.files.release)
+                throw failure('conflict', 'ownership completion lacks this task original owner file');
+            if (prior && task.local_roles.includes('sub') && !task.local_roles.includes('owner') && !await this.authorizeCleanup(context, prior)) {
+                task.status = 'pending';
+                task.step = 'cleanup_action_required';
+                task.cleanup_pending = true;
+                task.retryable = true;
+                await this.save(context);
+                this.event(context, 'ownership.action_required');
+                return true;
+            }
+        }
+        else {
+            if (task.local_decision !== 'accept')
+                return false;
+            if (task.operation === 'transfer' && task.local_roles.includes('owner') && !task.files.transfer)
+                throw failure('conflict', 'ownership completion lacks this task original transfer authorization');
+            consensus = await this.deps.files.checkConsensus(task.sub_aid, { owner_aid: targetOwner(task), relation_version: task.target_relation_version });
+            if (consensus.status !== 'consensus' || consensus.owner_aid !== targetOwner(task) || consensus.relation_version !== task.target_relation_version)
+                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)
+                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');
+        }
+        task.status = 'completed';
+        task.step = task.operation === 'release' ? 'released' : 'confirmed';
+        task.verified_relation_version = task.target_relation_version;
+        task.verified_consensus = { ...consensus, protocol: '2.1' };
+        delete task.code;
+        delete task.reason;
+        task.retryable = false;
+        task.cleanup_pending = task.operation === 'release' || task.operation === 'transfer' && task.local_roles.includes('owner');
+        if (task.operation === 'release' && task.local_roles.includes('owner'))
+            this.enqueue(task, task.sub_aid, 'relation.confirmed');
+        if (task.operation !== 'release' && task.local_roles.includes('sub'))
+            for (const peer of participants(task))
+                this.enqueue(task, peer, 'relation.confirmed');
+        if (!task.completed_event) {
+            task.completed_event = true;
+            await this.save(context);
+            this.event(context, 'ownership.completed', task.operation !== 'release' ? { consensus } : {});
+        }
+        else
+            await this.save(context);
+        return true;
+    }
+    async cleanupEvidence(task, evidence, raw) {
+        const release = task.files.release;
+        if (task.local_roles.includes('owner') && release && release.sha256 === evidence.owner_md_sha256 && release.sha256 === await ownershipSha256(release.raw))
+            return task.operation_id;
+        if (!task.local_roles.includes('sub'))
+            return undefined;
+        const matches = async (prepared) => Boolean(prepared && prepared.sha256 === evidence.agent_md_sha256 && prepared.sha256 === await ownershipSha256(prepared.raw) && (raw === undefined || prepared.raw === raw) && (prepared.published_etag === undefined || prepared.published_etag === evidence.agent_md_etag));
+        if (await matches(task.files.cleanup))
+            return task.operation_id;
+        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)
+                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;
+            if (statement?.owner_aid === task.owner_aid && statement.sub_aid === task.sub_aid && statement.relation_version === task.base_relation_version && this.sameStatement(statement, task.base_agent_md?.statement ?? undefined))
+                return candidate.operation_id;
+        }
+        return undefined;
+    }
+    sameStatement(left, right) {
+        return Boolean(left && right && ['version', 'declaration_id', 'owner_aid', 'sub_aid', 'relation_version', 'declared_at'].every((key) => left[key] === right[key]));
+    }
+    async authorizeCleanup(context, statement) {
+        const task = context.task;
+        const matches = (record) => ['bind', 'transfer'].includes(record.operation) && record.sub_aid === task.sub_aid && record.target_relation_version === task.base_relation_version && record.local_decision === 'accept' && record.local_roles.includes('sub') && targetOwner(record) === task.owner_aid && Boolean(record.files.agent && this.sameStatement(parseOwnershipFile(record.files.agent.raw, 'agent', { expectedSubAid: task.sub_aid }).statement, statement));
+        if (task.cleanup_authorization_operation_id) {
+            const saved = await this.load(task.cleanup_authorization_operation_id);
+            if (!saved || !matches(await this.record(saved)))
+                throw failure('persistence_unavailable', 'ownership cleanup historical authorization is damaged');
+            return true;
+        }
+        let history;
+        try {
+            history = await this.storage().listOwnershipTasks(context.aid);
+        }
+        catch (error) {
+            throw failure('persistence_unavailable', `ownership cleanup history read failed: ${String(error)}`);
+        }
+        const authorized = (await Promise.all(history.filter((row) => row.record.sub_aid === task.sub_aid).map((row) => this.record(row)))).find(matches);
+        if (!authorized)
+            return false;
+        task.cleanup_authorization_operation_id = authorized.operation_id;
+        await this.save(context);
+        return true;
+    }
+    async resumeSubCleanup(context, ns) {
+        const task = context.task;
+        if (!['bind', 'transfer'].includes(task.operation) || !task.local_roles.includes('sub') || task.local_decision !== 'accept' || ns.lock !== 'unlocked' || task.release_cleanup?.cleaned)
+            return;
+        if (ns.relation_version === 0 && !ns.file?.statement) {
+            const prepared = task.release_cleanup?.files.cleanup;
+            if (!prepared || !prepared.condition?.if_match || prepared.raw !== ns.content || prepared.sha256 !== await ownershipSha256(ns.content) || prepared.published_etag !== undefined && prepared.published_etag !== ns.etag)
+                throw failure('conflict', 'historical cleanup original file was not confirmed');
+            task.release_cleanup.cleaned = true;
+            await this.save(context);
+            return;
+        }
+        if (ns.relation_version !== task.target_relation_version)
+            return;
+        const consensus = await this.deps.files.checkConsensus(task.sub_aid);
+        if (consensus.status !== 'released' || consensus.relation_version !== ns.relation_version || consensus.agent_md_etag !== ns.etag || consensus.agent_md_sha256 !== await ownershipSha256(ns.content))
+            throw failure(consensus.status === 'invalid' ? 'invalid' : 'unavailable', 'NS changed during historical cleanup observation', consensus.status !== 'invalid');
+        const statement = ns.file?.statement;
+        if (!statement || !task.files.agent || !this.sameStatement(statement, parseOwnershipFile(task.files.agent.raw, 'agent', { expectedSubAid: task.sub_aid }).statement))
+            throw failure('conflict', 'historical cleanup fields belong to another relation');
+        if (!task.release_cleanup) {
+            task.release_cleanup = { files: {}, cleaned: false };
+            await this.save(context);
+        }
+        if (statement || task.release_cleanup.files.cleanup)
+            await this.deps.files.revokeOwneraid({ operation: 'release', sub_aid: task.sub_aid, owner_aid: targetOwner(task),
+                base_relation_version: task.target_relation_version, target_relation_version: ns.relation_version, files: task.release_cleanup.files, expected_agent_statement: statement,
+                persist: () => this.save(context), guard: () => this.save(context) });
+        task.release_cleanup.cleaned = true;
+        await this.save(context);
+        this.event(context, 'ownership.progress');
+    }
+    async cleanup(context, ns) {
+        const task = context.task;
+        if (!task.cleanup_pending || task.cleanup_done)
+            return;
+        const releaseOwner = task.operation === 'release' && task.local_roles.includes('owner');
+        const cleaned = task.operation === 'release' && ns.relation_version === 0 && ns.lock === 'unlocked' && !ns.file?.statement;
+        if (!this.isTarget(task, ns) && !cleaned && !releaseOwner) {
+            task.cleanup_pending = false;
+            task.step = 'cleanup_superseded';
+            await this.save(context);
+            return;
+        }
+        if (task.operation === 'release' && task.local_roles.includes('sub')) {
+            const prior = ns.file?.statement;
+            if (prior && !this.sameStatement(prior, task.base_agent_md?.statement ?? undefined))
+                throw failure('conflict', 'ownership cleanup original relation was replaced');
+            if (prior && !await this.authorizeCleanup(context, prior)) {
+                task.step = 'cleanup_action_required';
+                await this.save(context);
+                this.event(context, 'ownership.action_required');
+                return;
+            }
+            if (prior && (prior.owner_aid !== task.owner_aid || prior.relation_version !== task.base_relation_version))
+                throw failure('conflict', 'ownership cleanup current fields differ');
+            if (prior || task.files.cleanup)
+                await this.deps.files.revokeOwneraid(this.fileTask(context, prior));
+            this.enqueue(task, task.owner_aid, 'sub.cleaned');
+        }
+        if (task.local_roles.includes('owner') && (task.operation === 'release' || task.operation === 'transfer')) {
+            if (releaseOwner && this.isTarget(task, ns) && ns.file?.statement)
+                return;
+            const prepared = task.files[task.operation === 'release' ? 'release' : 'transfer'];
+            if (prepared) {
+                const object = await this.deps.files.readOwner(task.owner_aid, task.sub_aid);
+                if (object.exists && (object.sha256 !== prepared.sha256 || object.content !== prepared.raw))
+                    throw failure('conflict', 'ownership cleanup original owner file has been replaced');
+            }
+            await this.deps.files.cleanupOwnerFile(this.fileTask(context));
+        }
+        task.cleanup_pending = false;
+        task.cleanup_done = true;
+        task.step = 'cleanup_completed';
+        await this.save(context);
+        this.event(context, 'ownership.progress');
+    }
+    async drive(context) {
+        const task = context.task;
+        try {
+            if (context.observationError !== undefined && this.ongoing(task))
+                throw context.observationError;
+            await this.inbox(context);
+            if (task.status === 'error' && !task.retryable)
+                return;
+            let ns = await this.observe(task.sub_aid);
+            if (task.status === 'completed') {
+                await this.resumeSubCleanup(context, ns);
+                ns = await this.observe(task.sub_aid);
+                await this.cleanup(context, ns);
+                ns = await this.observe(task.sub_aid);
+                await this.flush(context, ns);
+                return;
+            }
+            if (['rejected', 'stopped'].includes(task.status) || task.status === 'error' && !task.retryable) {
+                await this.flush(context, ns);
+                return;
+            }
+            task.status = 'pending';
+            delete task.code;
+            delete task.reason;
+            task.retryable = true;
+            if (await this.complete(context, ns)) {
+                if (task.status === 'completed' && task.operation === 'release') {
+                    await this.cleanup(context, ns);
+                    ns = await this.observe(task.sub_aid);
+                }
+                await this.flush(context, ns);
+                return;
+            }
+            if (!this.isBase(task, ns))
+                throw failure(ns.lock === 'locked' && task.operation === 'bind' ? 'owner_locked' : 'conflict', 'ownership relation version or target was replaced');
+            await this.flush(context, ns);
+            if (task.local_decision === 'pending' && task.operation !== 'release') {
+                task.step = 'awaiting_local_approval';
+                await this.save(context);
+                if (task.request_validated)
+                    this.event(context, 'ownership.request');
+                return;
+            }
+            if (task.expires_at && task.expires_at <= this.now())
+                throw failure('conflict', 'ownership transfer authorization expired');
+            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));
+                    this.enqueue(task, task.sub_aid, 'owner.ready');
+                    if (task.local_roles.includes('sub'))
+                        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)) {
+                    await this.deps.files.declareOwneraid(this.fileTask(context));
+                }
+                task.step = accepted ? 'awaiting_confirmation' : 'awaiting_peer_approval';
+            }
+            else if (task.operation === 'transfer') {
+                if (task.local_roles.includes('owner') && accepted) {
+                    await this.deps.files.transferOwneraid(this.fileTask(context));
+                    for (const peer of [...new Set([task.sub_aid, task.new_owner_aid])])
+                        this.enqueue(task, peer, 'transfer.ready');
+                    if (task.local_roles.includes('sub'))
+                        task.hints['transfer.ready'] = true;
+                    await this.save(context);
+                }
+                if (task.local_roles.includes('new_owner') && (task.hints['transfer.ready'] || task.files.owner)) {
+                    await this.deps.files.declareSubaid(this.fileTask(context));
+                    this.enqueue(task, task.sub_aid, 'owner.ready');
+                    if (task.local_roles.includes('sub'))
+                        task.hints['owner.ready'] = true;
+                    await this.save(context);
+                }
+                if (task.local_roles.includes('sub') && (task.hints['owner.ready'] || task.files.agent) && (task.hints['transfer.ready'] || task.local_roles.includes('owner')))
+                    await this.deps.files.declareOwneraid(this.fileTask(context));
+                task.step = accepted || task.hints['transfer.ready'] ? 'awaiting_confirmation' : 'awaiting_peer_approval';
+            }
+            else {
+                if (task.local_roles.includes('owner'))
+                    await this.deps.files.revokeSubaid(this.fileTask(context));
+                task.step = 'awaiting_release_confirmation';
+            }
+            await this.save(context);
+            ns = await this.observe(task.sub_aid);
+            await this.complete(context, ns);
+            await this.flush(context, ns);
+            this.event(context, 'ownership.progress');
+        }
+        catch (error) {
+            let code = ownershipErrorCode(error);
+            if (code === 'conflict' && /\blease\b|fencing|task revision/.test(String(error)))
+                throw failure('persistence_unavailable', error instanceof Error ? error.message : String(error));
+            if (code === 'persistence_unavailable')
+                throw error;
+            if (task.status !== 'completed' && !['rejected', 'stopped'].includes(task.status) && (code === 'conflict' || code === 'owner_locked')) {
+                try {
+                    const current = await this.observe(task.sub_aid);
+                    if (await this.complete(context, current)) {
+                        await this.flush(context, current);
+                        return;
+                    }
+                }
+                catch (confirmationError) {
+                    code = ownershipErrorCode(confirmationError);
+                    error = confirmationError;
+                    if (code === 'persistence_unavailable')
+                        throw confirmationError;
+                }
+            }
+            task.code = code;
+            task.reason = error instanceof Error ? error.message : String(error);
+            task.retryable = !['completed', 'rejected', 'stopped'].includes(task.status) && (code === 'unavailable' || code === 'unsupported_protocol');
+            if (task.status !== 'completed' && !['rejected', 'stopped'].includes(task.status)) {
+                task.status = task.retryable ? 'pending' : code === 'conflict' || code === 'owner_locked' ? 'stopped' : 'error';
+                if (!task.retryable) {
+                    task.step = 'stopped';
+                    task.inbox = [];
+                    task.outbox = task.outbox.filter((item) => ['bind.reject', 'transfer.reject', 'operation.stopped'].includes(item.payload.action));
+                }
+            }
+            await this.save(context);
+            this.event(context, task.status === 'stopped' ? 'ownership.stopped' : 'ownership.error');
+        }
+    }
+}
+//# sourceMappingURL=ownership-workflow.js.map