sealbridge 0.1.0 → 0.2.0

package/dist/packages/runtime/dist/session.js

@@ -5,14 +5,16 @@ import { existsSync, openSync, closeSync, fstatSync, fchmodSync, appendFileSync,
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { randomUUID } from 'node:crypto';
-import { createContract, createCapability, createSignedAgentCard, createInviteToken, parseAndVerifyInviteToken, validateRelayEndpointUrl, signPayload, verifySigned, verifyEnvelope, verifyContract, verifyApproval, validateManifest, validateOutput, verifyCapabilityChain, capabilityIssuerControls, findDiscoveredAgentCard, discoverAgentCards, schemaNarrows, digest, openEnvelope, inviteRevocationId, resolveDid, createRevocationNotice, verifyRevocationNotice, RevocationRegistry, signEnvelope, DEFAULT_CLOCK_SKEW_MS, OPEN_POLICY_FIELDS, } from '../../core/dist/index.js';
-import { verifyAudit } from '../../ledger/dist/index.js';
-import { HttpRelayClient } from '../../relay/dist/index.js';
+import { createContract, createCapability, createSignedAgentCard, createInviteToken, parseAndVerifyInviteToken, isInviteTarget, validateRelayEndpointUrl, signPayload, verifySigned, verifyEnvelope, verifyContract, verifyApproval, validateManifest, validateOutput, verifyCapabilityChain, capabilityIssuerControls, findDiscoveredAgentCard, discoverAgentCards, schemaNarrows, digest, openEnvelope, resolveDid, createRevocationNotice, verifyRevocationNotice, RevocationRegistry, signEnvelope, DEFAULT_CLOCK_SKEW_MS, OPEN_POLICY_FIELDS, } from '../../core/dist/index.js';
+import { parseJsonl, verifyAudit } from '../../ledger/dist/index.js';
+import { HttpRelayClient, waitForRelayRetry, relayDiagnostic, relayDeadline } from '../../relay/dist/index.js';
 import { InteractiveCliApprovalProvider, ProposalRejectedError, evaluateContractAcceptance, } from './approval-providers.js';
 import { OwnerGateway } from './gateway.js';
 import { MCPProxy } from './mcp.js';
 import { VerificationEngine, createDelivery } from './verifier.js';
-import { asJson, receiveRelay, acknowledgeRelay, SessionWire } from './session-audit.js';
+import { asJson, receiveRelay, acknowledgeRelay, PeerRejectedError, SessionWire } from './session-audit.js';
+import { SessionTimeouts, validateSessionTimeouts, resolveSessionTimeouts } from './session-timeouts.js';
+import { TaskJournal } from './task-journal.js';
 const policy = { requiredGates: [], autoApprove: [] };
 /** Daemon workers stay finite unless the owner raises the cap. */
 export const DEFAULT_MAX_CONCURRENT_TASKS = 8;
@@ -58,15 +60,31 @@ function transport(relay, owner, security) {
         ? new HttpRelayClient(relay.replace(/\/$/, ''), owner, security)
         : relay;
     client.setRecipientKey?.(owner);
-    return client.withRecipient?.(owner) ?? client;
+    const bound = client.withRecipient?.(owner) ?? client;
+    return {
+        get connectionStatus() { return bound.connectionStatus; },
+        send: (envelope) => relayDeadline(Promise.resolve(bound.send(envelope)), security?.requestTimeoutMs ?? 45_000),
+        receive: async (did, waitMs, signal, filter) => {
+            const controller = new AbortController();
+            const readSignal = AbortSignal.any([controller.signal, ...(signal ? [signal] : [])]);
+            try {
+                return await relayDeadline(Promise.resolve(bound.receive(did, waitMs, readSignal, filter)), security?.requestTimeoutMs ?? 45_000, readSignal);
+            }
+            catch (error) {
+                controller.abort(error);
+                throw error;
+            }
+        },
+        ...(bound.acknowledgeDelivery ? { acknowledgeDelivery: (did, id) => relayDeadline(Promise.resolve(bound.acknowledgeDelivery(did, id)), security?.requestTimeoutMs ?? 45_000) } : {}),
+        ...(bound.deliveryStatus ? { deliveryStatus: (envelope, signal) => relayDeadline(Promise.resolve(bound.deliveryStatus(envelope, signal)), security?.requestTimeoutMs ?? 45_000, signal) } : {}),
+        ...(bound.register ? { register: (card) => bound.register(card) } : {}),
+        ...(bound.discover ? { discover: () => relayDeadline(Promise.resolve(bound.discover()), security?.requestTimeoutMs ?? 45_000) } : {}),
+    };
 }
 function freshAudit(path) {
     if (path && existsSync(path))
         throw new Error('AUDIT_FILE_ALREADY_EXISTS');
 }
-function sessionSignal(timeout, signal) {
-    return AbortSignal.any([AbortSignal.timeout(timeout), ...(signal ? [signal] : [])]);
-}
 /** Cleartext is rejected unless the owner explicitly opts out for a legacy fixture. */
 function sessionDecryptOptions(allowUnencryptedEnvelopes) {
     return { requireEncrypted: allowUnencryptedEnvelopes !== true };
@@ -74,6 +92,12 @@ function sessionDecryptOptions(allowUnencryptedEnvelopes) {
 /** Per-task queue so one session cannot dequeue another task's envelopes. */
 class TaskMailbox {
     queue = [];
+    error;
+    close(error) {
+        this.error ??= error;
+        for (const wake of this.waiters.splice(0))
+            wake();
+    }
     waiters = [];
     push(envelope) {
         this.queue.push(envelope);
@@ -81,6 +105,8 @@ class TaskMailbox {
     }
     async take(signal) {
         for (;;) {
+            if (this.error)
+                throw this.error;
             signal?.throwIfAborted();
             const next = this.queue.shift();
             if (next)
@@ -95,7 +121,7 @@ class TaskMailbox {
                     this.waiters = this.waiters.filter((waiter) => waiter !== onWake);
                     error ? reject(error) : resolve();
                 };
-                const onAbort = () => finish(new Error('SESSION_ABORTED'));
+                const onAbort = () => finish(signal?.reason instanceof Error ? signal.reason : new Error('SESSION_ABORTED'));
                 const onWake = () => finish();
                 this.waiters.push(onWake);
                 signal?.addEventListener('abort', onAbort, { once: true });
@@ -110,6 +136,7 @@ class TaskMailbox {
 function mailboxRelay(relay, mailbox) {
     return {
         send: (envelope) => relay.send(envelope),
+        ...(relay.deliveryStatus ? { deliveryStatus: (envelope, signal) => relay.deliveryStatus(envelope, signal) } : {}),
         ...(relay.acknowledgeDelivery ? { acknowledgeDelivery: (did, id) => relay.acknowledgeDelivery(did, id) } : {}),
         receive: (_recipientDid, _waitMs, signal) => mailbox.take(signal),
     };
@@ -189,6 +216,7 @@ class RecipientInbox {
     wake;
     readAbort;
     started = false;
+    error;
     constructor(relay, did) {
         this.relay = relay;
         this.did = did;
@@ -204,6 +232,8 @@ class RecipientInbox {
         return true;
     }
     attach(taskId) {
+        if (this.error)
+            throw this.error;
         const existing = this.mailboxes.get(taskId);
         if (existing)
             return existing;
@@ -258,8 +288,15 @@ class RecipientInbox {
                 }
                 this.mailboxes.get(envelope.payload.taskId)?.push(envelope);
             }
-            catch {
-                // The last mailbox closed, or the transport aborted this read.
+            catch (error) {
+                if (controller.signal.aborted)
+                    continue;
+                this.error = relayDiagnostic(error);
+                controller.abort(this.error);
+                for (const mailbox of this.mailboxes.values())
+                    mailbox.close(this.error);
+                unregisterRequesterInbox(this.did, this);
+                return;
             }
         }
     }
@@ -324,6 +361,8 @@ export class WorkerNode {
     acceptance;
     completed = 0;
     activeTasks = 0;
+    taskJournal;
+    reconciled = false;
     proposalTimes = new Map();
     mailboxes = new Map();
     forwardedQueue = [];
@@ -340,6 +379,13 @@ export class WorkerNode {
     revocation;
     constructor(options) {
         this.options = options;
+        validateSessionTimeouts(options);
+        if (options.inviteTtlSeconds !== undefined && (!Number.isSafeInteger(options.inviteTtlSeconds) ||
+            options.inviteTtlSeconds < 1 || options.inviteTtlSeconds > 2592000))
+            throw new Error('INVALID_INVITE_TTL');
+        const persistencePath = options.inboxPath ?? options.auditPath;
+        if (persistencePath)
+            this.taskJournal = new TaskJournal(persistencePath + '.tasks.jsonl', options.owner);
         if (options.dailyLimit && (!options.dailyLimit.path || !Number.isSafeInteger(options.dailyLimit.maxTasks) || options.dailyLimit.maxTasks < 1))
             throw new Error('INVALID_DAILY_LIMIT');
         if (options.accessMode !== undefined && !['invite-only', 'open'].includes(options.accessMode))
@@ -354,6 +400,7 @@ export class WorkerNode {
         this.relay = this.revocationAwareRelay(transport(options.relay, options.owner, {
             allowPrivateRelay: options.allowPrivateRelay,
             lookup: options.lookup,
+            requestTimeoutMs: options.connectTimeoutMs,
         }));
         this.approvalProvider =
             options.approvalProvider ?? new InteractiveCliApprovalProvider(options.owner);
@@ -365,11 +412,14 @@ export class WorkerNode {
                 ? options.relay
                 : (options.relayUrl ?? 'http://in-memory.invalid'),
             skills: options.adapter.skills,
+            ...(options.inviteTtlSeconds !== undefined ? {
+                expiresAt: new Date(Date.now() + options.inviteTtlSeconds * 1000).toISOString(),
+            } : {}),
             ...(options.accessMode ? { accessMode: options.accessMode } : {}),
             ...(options.openPolicy !== undefined ? { openPolicy: options.openPolicy } : {}),
         }, options.owner, agentDid === options.owner.did ? undefined : options.agentKey);
     }
-    invite(expiresInSeconds = 3600) {
+    invite(expiresInSeconds = this.options.inviteTtlSeconds ?? 86400) {
         return createInviteToken({ agentCard: this.agentCard, expiresInSeconds }, this.options.owner);
     }
     async register() {
@@ -377,6 +427,7 @@ export class WorkerNode {
     }
     stop() {
         this.controller.abort('WORKER_STOPPED');
+        this.listenerStatus('stopped');
     }
     /** Public registration is opt-in, including for PolicyAutoApprovalProvider. */
     publishes() {
@@ -431,9 +482,23 @@ export class WorkerNode {
             return undefined;
         }
     }
+    status;
+    listenerStatus(status, error) {
+        if (this.status === status && !error)
+            return;
+        this.status = status;
+        this.options.onStatus?.(status, error);
+    }
+    listen(signal) {
+        return receiveRelay(this.relay, this.options.owner.did, signal, { role: 'worker' }, (status) => this.listenerStatus(status === 'connected' ? this.relay.connectionStatus ?? status : status))
+            .catch((error) => { if (signal.aborted)
+            throw error; throw relayDiagnostic(error); });
+    }
     async start(options = {}) {
+        // Register first so immediate discovery can resolve owner and agent aliases.
         if (this.publishes())
             await this.register();
+        await this.reconcileTasks();
         const idleSignal = AbortSignal.any([
             this.controller.signal,
             ...(options.signal ? [options.signal] : []),
@@ -447,11 +512,12 @@ export class WorkerNode {
         try {
             while (!idleSignal.aborted) {
                 // revocationAwareRelay ingests a leading REVOKE before this read returns.
-                const envelope = await receiveRelay(this.relay, this.options.owner.did, idleSignal, {
-                    role: 'worker',
-                });
-                if (await this.alreadyPersisted(envelope))
+                const envelope = await this.listen(idleSignal);
+                if (await this.recoverProposal(envelope)) {
+                    if (options.once)
+                        return this.lastResult;
                     continue;
+                }
                 if (this.deliver(envelope))
                     continue;
                 const job = this.beginTask(envelope, idleSignal, options.once === true);
@@ -466,35 +532,140 @@ export class WorkerNode {
             }
         }
         catch (error) {
-            if (!idleSignal.aborted)
+            if (!idleSignal.aborted) {
+                // A rejected one-shot task may be followed by another start on this node.
+                // Only a terminal listener failure shuts down the worker and all of its tasks.
+                if (error instanceof Error && 'code' in error && error.code === 'RELAY_TERMINAL') {
+                    this.listenerStatus('unavailable', error);
+                    for (const mailbox of this.mailboxes.values())
+                        mailbox.close(error);
+                    this.controller.abort(error);
+                }
                 throw error;
+            }
         }
         finally {
+            if (this.status !== 'unavailable')
+                this.listenerStatus('stopped');
             unregister();
             await Promise.allSettled([...jobs]);
         }
         return this.lastResult;
     }
-    persistedEnvelopeIds;
-    async alreadyPersisted(envelope) {
-        if (!this.options.inboxPath || envelope.payload.eventType !== 'PROPOSE' ||
+    async notifyOutcome(record, outcome = record.outcome) {
+        const send = (recovery) => this.relay.send(signEnvelope({ taskId: record.taskId,
+            recipientDid: record.requesterDid, seq: 0, eventType: 'ERROR',
+            payload: asJson({ code: outcome.code, recovery }),
+        }, this.options.owner, { encrypt: true }));
+        const bytes = outcome.result ? Buffer.from(JSON.stringify(outcome.result)) : undefined;
+        // Cached audits can exceed a single relay envelope even when every original event fitted.
+        if (bytes && bytes.length > 48 * 1024) {
+            const size = 24 * 1024, count = Math.ceil(bytes.length / size), resultDigest = digest(outcome.result);
+            for (let index = 0; index < count; index++) {
+                await send({ proposalDigest: record.proposalDigest, part: { index, count, resultDigest,
+                        data: bytes.subarray(index * size, (index + 1) * size).toString('base64') } });
+                // Yield to inbox readers so a cached audit does not fill the bounded relay queue.
+                if (index + 1 < count)
+                    await waitForRelayRetry(10, this.controller.signal);
+            }
+        }
+        else {
+            await send({ proposalDigest: record.proposalDigest, ...(outcome.result ? { result: outcome.result } : {}) });
+        }
+    }
+    async reconcileTasks() {
+        if (this.reconciled || !this.taskJournal)
+            return;
+        this.taskJournal.load();
+        for (const saved of this.taskJournal.tasks.values()) {
+            let record = saved;
+            if (record.phase !== 'terminal') {
+                const result = this.sealedTaskResult(record);
+                // Adapters expose executeTask only. Unknown execution/tool results cannot be retried safely.
+                record = { ...record, phase: 'terminal', outcome: result
+                        ? { code: result.state === 'SETTLED' ? 'TASK_SETTLED' : 'TASK_CANCELLED', result }
+                        : { code: 'TASK_INTERRUPTED' }, notificationPending: true };
+                this.taskJournal.save(record);
+                if (!result)
+                    this.options.onEvent?.('INTERRUPTED', record.taskId, { code: 'TASK_INTERRUPTED' });
+            }
+            if (record.notificationPending) {
+                await this.notifyOutcome(record);
+                this.taskJournal.save({ ...record, notificationPending: false });
+            }
+        }
+        this.reconciled = true;
+    }
+    sealedTaskResult(record) {
+        if (!record.auditPath)
+            return;
+        try {
+            const bundle = parseJsonl(readFileSync(record.auditPath, 'utf8'));
+            if (!verifyAudit(bundle, { taskId: record.taskId, actors: [record.requesterDid, this.options.owner.did] }).valid)
+                return;
+            const proposal = bundle.entries.find((entry) => entry.body.eventType === 'PROPOSE')?.body.payload;
+            if (!proposal || digest({ manifest: proposal.proposal.payload, input: proposal.input }) !== record.proposalDigest)
+                return;
+            const last = bundle.entries.at(-1)?.body.eventType;
+            if (last === 'CANCEL')
+                return { taskId: record.taskId, state: 'CANCELLED', deliverable: null, bundle };
+            const delivery = bundle.entries.find((entry) => entry.body.eventType === 'DELIVER')?.body.payload;
+            if (last === 'SETTLED' && delivery)
+                return { taskId: record.taskId, state: 'SETTLED', deliverable: delivery.artifact.payload.data, bundle };
+        }
+        catch { /* An unsealed or partial audit is evidence to preserve, not authorization to rerun. */ }
+        return undefined;
+    }
+    async recoverProposal(envelope) {
+        if (!this.taskJournal || envelope.payload.eventType !== 'PROPOSE' || envelope.payload.seq !== 0 ||
             !verifyEnvelope(envelope, this.options.owner.did))
             return false;
-        if (!this.persistedEnvelopeIds) {
-            this.persistedEnvelopeIds = new Set();
-            if (existsSync(this.options.inboxPath)) {
-                for (const line of readFileSync(this.options.inboxPath, 'utf8').split('\n')) {
-                    try {
-                        const record = JSON.parse(line);
-                        if (typeof record.envelopeId === 'string')
-                            this.persistedEnvelopeIds.add(record.envelopeId);
-                    }
-                    catch { /* A partial final write is not proof of persistence. */ }
+        let data;
+        try {
+            data = openEnvelope(envelope, this.options.owner, sessionDecryptOptions(this.options.allowUnencryptedEnvelopes));
+        }
+        catch {
+            return false;
+        }
+        const manifest = data?.proposal?.payload;
+        if (!manifest || !verifySigned(data.proposal, envelope.payload.senderDid) ||
+            manifest.taskId !== envelope.payload.taskId || manifest.requester?.ownerDid !== envelope.payload.senderDid)
+            return false;
+        const proposalDigest = digest({ manifest, input: data.input });
+        let record = this.taskJournal.tasks.get(manifest.taskId);
+        // Older inboxes have intake evidence but no execution checkpoint. Never execute those tasks again.
+        if (!record && this.options.inboxPath && existsSync(this.options.inboxPath)) {
+            for (const line of readFileSync(this.options.inboxPath, 'utf8').split('\n')) {
+                let old;
+                try {
+                    old = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (old?.taskId === manifest.taskId && old.requesterOwnerDid === envelope.payload.senderDid) {
+                    record = { version: 1, taskId: manifest.taskId, requesterDid: envelope.payload.senderDid,
+                        envelopeId: envelope.payload.envelopeId, proposalDigest, phase: 'terminal', invocations: [],
+                        outcome: { code: 'TASK_INTERRUPTED' } };
+                    this.taskJournal.save(record);
+                    break;
                 }
             }
         }
-        if (!this.persistedEnvelopeIds.has(envelope.payload.envelopeId))
+        if (!record)
             return false;
+        this.lastResult = undefined;
+        if (record.requesterDid !== envelope.payload.senderDid || record.proposalDigest !== proposalDigest) {
+            await this.notifyOutcome({ ...record, requesterDid: envelope.payload.senderDid, proposalDigest }, { code: 'TASK_ID_CONFLICT' });
+        }
+        else if (record.outcome) {
+            await this.notifyOutcome(record);
+            this.lastResult = record.outcome.result;
+        }
+        else if (!this.mailboxes.has(record.taskId)) {
+            throw new Error('TASK_RECOVERY_REQUIRED');
+        }
+        // The outcome must be sent successfully before a retried intake is removed.
         await acknowledgeRelay(this.relay, envelope);
         return true;
     }
@@ -571,7 +742,7 @@ export class WorkerNode {
         });
         try {
             while (!idleSignal.aborted && failure === undefined) {
-                const incoming = receiveRelay(this.relay, this.options.owner.did, AbortSignal.any([idleSignal, wait.signal]), { role: 'worker' }).then((envelope) => envelope, (error) => {
+                const incoming = this.listen(AbortSignal.any([idleSignal, wait.signal])).then((envelope) => envelope, (error) => {
                     if (!idleSignal.aborted && !wait.signal.aborted)
                         failure = error;
                     return undefined;
@@ -583,6 +754,8 @@ export class WorkerNode {
                 // not delivered here. The next session envelope is what remains.
                 if (!envelope)
                     return;
+                if (await this.recoverProposal(envelope))
+                    continue;
                 if (!this.deliver(envelope) && verifyEnvelope(envelope, this.options.owner.did))
                     this.options.onEvent?.('REJECTED', envelope.payload.taskId, { code: 'INVALID_SESSION_ENVELOPE' });
             }
@@ -594,14 +767,17 @@ export class WorkerNode {
             throw failure;
     }
     async runOnce(signal) {
+        await this.reconcileTasks();
         const idleSignal = AbortSignal.any([this.controller.signal, ...(signal ? [signal] : [])]);
         // One or more leading REVOKE envelopes are consumed before the task PROPOSE.
-        let first;
-        do {
-            first = await receiveRelay(this.relay, this.options.owner.did, idleSignal, {
-                role: 'worker',
-            });
-        } while (await this.alreadyPersisted(first));
+        const first = await receiveRelay(this.relay, this.options.owner.did, idleSignal, {
+            role: 'worker',
+        });
+        if (await this.recoverProposal(first)) {
+            if (this.lastResult?.taskId === first.payload.taskId)
+                return this.lastResult;
+            throw new Error(this.taskJournal?.tasks.get(first.payload.taskId)?.outcome?.code ?? 'TASK_INTERRUPTED');
+        }
         return this.executeTask(first, idleSignal, this.relay);
     }
     async executeTask(first, idleSignal, relay, earlyRejection) {
@@ -614,6 +790,16 @@ export class WorkerNode {
         let data;
         let m;
         let auditPath;
+        let checkpoint;
+        const saveCheckpoint = (patch) => {
+            if (!checkpoint || !this.taskJournal)
+                return;
+            checkpoint = { ...checkpoint, ...patch };
+            this.taskJournal.save(checkpoint);
+        };
+        const saveOutcome = (outcome) => {
+            saveCheckpoint({ phase: 'terminal', outcome, notificationPending: true });
+        };
         try {
             data = openEnvelope(first, this.options.owner, sessionDecryptOptions(this.options.allowUnencryptedEnvelopes));
             const manifest = data?.proposal?.payload;
@@ -634,6 +820,12 @@ export class WorkerNode {
                     : this.options.auditPath.replace(/(?:\.jsonl)?$/, '.' + m.taskId + '.jsonl')
                 : undefined;
             freshAudit(auditPath);
+            if (this.taskJournal) {
+                checkpoint = { version: 1, taskId: m.taskId, requesterDid: m.requester.ownerDid,
+                    envelopeId: first.payload.envelopeId, proposalDigest: digest({ manifest: m, input: data.input }),
+                    phase: 'received', auditPath, invocations: [] };
+                this.taskJournal.save(checkpoint);
+            }
         }
         catch (e) {
             this.reportRejection(first.payload.taskId, e);
@@ -651,11 +843,25 @@ export class WorkerNode {
             }
             throw e;
         }
-        const activeSignal = sessionSignal(Math.min(this.options.timeoutMs ?? 120000, Date.parse(m.deadline) - Date.now()), idleSignal);
+        const timeouts = new SessionTimeouts(this.options, m.deadline, idleSignal);
+        const activeSignal = timeouts.signal;
         const wire = new SessionWire(relay, this.options.owner, m.requester.ownerDid, m.taskId, [m.requester.ownerDid, this.options.owner.did], activeSignal, auditPath, this.options.allowUnencryptedEnvelopes === true);
         const cancelController = new AbortController();
         wire.earlyCancel = () => cancelController.abort('CANCELLED');
+        let heartbeat;
+        let heartbeatStopped = false;
+        const sendHeartbeat = async () => {
+            try {
+                await wire.heartbeat();
+            }
+            catch { /* The supervised reader reports relay availability. */ }
+            if (!heartbeatStopped && !activeSignal.aborted) {
+                heartbeat = setTimeout(() => void sendHeartbeat(), this.options.heartbeatIntervalMs ?? 15_000);
+                heartbeat.unref();
+            }
+        };
         let gateway, workspace;
+        let preserveWorkspace = false;
         let trackedTaskId;
         // Progress metrics are applied synchronously. The tail only serializes wire frames.
         let progressTail = Promise.resolve();
@@ -696,20 +902,30 @@ export class WorkerNode {
             validateManifest(m);
             if (!validateOutput(m.io.inputSchema, data.input))
                 throw new Error('INVALID_PROPOSAL');
+            if (this.options.executionTimeoutMs !== undefined && m.budget.maxWallClockSeconds * 1000 > this.options.executionTimeoutMs)
+                throw diagnosticError('INCOMPATIBLE_TIMEOUTS', 'budget.maxWallClockSeconds', this.options.executionTimeoutMs / 1000, m.budget.maxWallClockSeconds, 'Reduce the execution budget or raise the worker execution timeout before accepting.');
+            if (this.options.taskTimeoutMs !== undefined && m.budget.maxWallClockSeconds * 1000 > this.options.taskTimeoutMs)
+                throw diagnosticError('INCOMPATIBLE_TIMEOUTS', 'budget.maxWallClockSeconds', this.options.taskTimeoutMs / 1000, m.budget.maxWallClockSeconds, 'Reduce the execution budget or raise the worker overall task timeout before accepting.');
+            if (data.peerIdleTimeoutMs !== undefined &&
+                (!Number.isSafeInteger(data.peerIdleTimeoutMs) || data.peerIdleTimeoutMs < 1 ||
+                    (this.options.heartbeatIntervalMs ?? 15_000) >= data.peerIdleTimeoutMs))
+                throw diagnosticError('INCOMPATIBLE_TIMEOUTS', 'peerIdleTimeoutMs', { greaterThan: this.options.heartbeatIntervalMs ?? 15_000 }, data.peerIdleTimeoutMs, 'Raise the requester idle timeout or shorten the worker heartbeat interval before accepting.');
             const contract = createContract(m, data.proposal, this.options.owner);
-            const approval = await this.approvalProvider.approve({
+            const approval = await abortable(this.approvalProvider.approve({
                 taskId: m.taskId,
                 gate: 'contract_acceptance',
                 target: contract.contractDigest,
                 details: {
                     manifest: m,
+                    input: data.input,
                     capabilities: data.capabilityChains,
                     from: first.payload.senderDid,
                 },
                 signal: activeSignal,
-            });
+            }), activeSignal);
             gateway = new OwnerGateway(this.options.owner, contract, policy, this.revocation);
             const accepted = gateway.accept(approval);
+            saveCheckpoint({ phase: 'accepted' });
             if (this.options.dailyLimit)
                 consumeDailyTask(this.options.dailyLimit.path, this.options.dailyLimit.maxTasks, m.taskId);
             if (this.options.inboxPath) {
@@ -735,7 +951,6 @@ export class WorkerNode {
                 finally {
                     closeSync(fd);
                 }
-                this.persistedEnvelopeIds?.add(first.payload.envelopeId);
                 await acknowledgeRelay(relay, first);
                 // Notification errors must not fail a persisted task.
                 try {
@@ -748,6 +963,9 @@ export class WorkerNode {
             await wire.sendEvent('ACCEPT', { contract, transition: accepted, approval });
             this.options.onEvent?.('ACCEPT', m.taskId);
             await wire.sendEvent('START', gateway.transition('START'));
+            heartbeat = setTimeout(() => void sendHeartbeat(), this.options.heartbeatIntervalMs ?? 15_000);
+            heartbeat.unref();
+            timeouts.running();
             this.options.onEvent?.('IN_PROGRESS', m.taskId);
             const extra = this.options.adapter;
             const tools = this.options.tools ?? extra.tools ?? {}, backend = this.options.toolBackend ?? extra.toolBackend;
@@ -791,6 +1009,8 @@ export class WorkerNode {
                 });
             });
             workspace = await mkdtemp(join(tmpdir(), 'acp-adapter-'));
+            saveCheckpoint({ phase: 'running', workspace });
+            let invocationCount = 0;
             const executionSignal = AbortSignal.any([
                 activeSignal,
                 gateway.quota.controller.signal,
@@ -895,7 +1115,15 @@ export class WorkerNode {
                             signal: executionSignal,
                         })
                         : undefined;
-                    return asJson(await proxies[index].callTool(tool, args, approval));
+                    executionSignal.throwIfAborted();
+                    const invocation = { id: m.taskId + ':' + invocationCount++, tool,
+                        argsDigest: digest(args), completed: false };
+                    saveCheckpoint({ invocations: [...(checkpoint?.invocations ?? []), invocation] });
+                    const result = asJson(await proxies[index].callTool(tool, args, approval));
+                    // A backend may finish after cancellation. Leave its uncertain result for inspection.
+                    if (!executionSignal.aborted)
+                        saveCheckpoint({ invocations: (checkpoint?.invocations ?? []).map((call) => call.id === invocation.id ? { ...call, completed: true } : call) });
+                    return result;
                 },
             };
             const output = await abortable(this.options.adapter.executeTask(context), executionSignal);
@@ -915,19 +1143,29 @@ export class WorkerNode {
                 ...(sandboxBoundary ? { sandboxBoundary } : {}),
             });
             const transition = gateway.transition('DELIVER');
+            saveCheckpoint({ phase: 'delivered' });
             await wire.sendEvent('DELIVER', { ...delivery, transition });
             this.options.onEvent?.('DELIVER', m.taskId);
+            timeouts.wait();
             const verification = await wire.receiveEvent(['VERIFY_ACCEPT', 'VERIFY_REJECT']);
             gateway.machine.apply(verification.payload.payload);
             if (verification.payload.eventType === 'VERIFY_REJECT')
                 throw new Error('VERIFICATION_REJECTED');
             const settled = await wire.receiveEvent('SETTLED');
             gateway.machine.apply(settled.payload.payload);
-            const bundle = await wire.finishWorker();
+            const bundle = await wire.finishWorker((sealed) => {
+                saveOutcome({ code: 'TASK_SETTLED', result: { taskId: m.taskId, state: 'SETTLED', deliverable: output, bundle: sealed } });
+            });
+            saveCheckpoint({ notificationPending: false });
             this.options.onEvent?.('SETTLED', m.taskId);
             return { taskId: m.taskId, state: 'SETTLED', deliverable: output, bundle };
         }
         catch (e) {
+            if (checkpoint?.outcome?.result) {
+                // The bilateral checkpoint is already durable even if its final relay send failed.
+                await this.notifyOutcome(checkpoint).then(() => saveCheckpoint({ notificationPending: false })).catch(() => { });
+                return checkpoint.outcome.result;
+            }
             if (gateway &&
                 (wire.cancelHandled || cancelController.signal.aborted) &&
                 ['ACCEPTED', 'IN_PROGRESS', 'CANCELLED'].includes(gateway.machine.state)) {
@@ -938,7 +1176,10 @@ export class WorkerNode {
                         throw new Error('INVALID_CANCEL');
                     if (gateway.machine.state !== 'CANCELLED')
                         gateway.machine.apply(body.transition);
-                    const bundle = await wire.finishWorker();
+                    const bundle = await wire.finishWorker((sealed) => {
+                        saveOutcome({ code: 'TASK_CANCELLED', result: { taskId: m.taskId, state: 'CANCELLED', deliverable: null, bundle: sealed } });
+                    });
+                    saveCheckpoint({ notificationPending: false });
                     this.options.onEvent?.('CANCELLED', m.taskId);
                     return { taskId: m.taskId, state: 'CANCELLED', deliverable: null, bundle };
                 }
@@ -948,10 +1189,16 @@ export class WorkerNode {
                 }
             }
             await progressTail;
+            preserveWorkspace = activeSignal.aborted || idleSignal.aborted;
+            if (idleSignal.aborted)
+                throw e;
+            const diagnostic = preserveWorkspace ? { code: 'TASK_INTERRUPTED' } : rejectionBody(progressFailure ?? e);
+            saveOutcome(diagnostic);
             this.reportRejection(m.taskId, progressFailure ?? e);
             if (!wireFailureSent) {
                 wireFailureSent = true;
-                await wire.rawSend('ERROR', rejectionBody(progressFailure ?? e)).catch(() => { });
+                await wire.rawSend('ERROR', diagnostic)
+                    .then(() => saveCheckpoint({ notificationPending: false })).catch(() => { });
             }
             // A quota abort already surfaces as EXECUTION_ABORTED. Keep that error.
             // A caught INVALID_PROGRESS still fails the session with the sticky error.
@@ -961,11 +1208,32 @@ export class WorkerNode {
             throw e;
         }
         finally {
+            heartbeatStopped = true;
+            clearTimeout(heartbeat);
+            timeouts.close();
+            wire.close();
             if (trackedTaskId)
                 this.liveChains.delete(trackedTaskId);
             gateway?.close();
-            if (workspace)
-                await rm(workspace, { recursive: true, force: true });
+            if (idleSignal.aborted && checkpoint?.phase !== 'terminal')
+                preserveWorkspace = true;
+            if (workspace && !preserveWorkspace) {
+                try {
+                    await rm(workspace, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 });
+                }
+                catch (error) {
+                    const code = error?.code ?? 'WORKSPACE_CLEANUP_FAILED';
+                    // Reporting residual files must not replace settlement or the execution error.
+                    try {
+                        if (this.options.onWorkspaceCleanupError)
+                            void Promise.resolve(this.options.onWorkspaceCleanupError({ taskId: m.taskId, workspaceDir: workspace, code }))
+                                .catch(() => { });
+                        else
+                            console.warn('Workspace cleanup incomplete (' + code + '): ' + workspace);
+                    }
+                    catch { }
+                }
+            }
         }
     }
     /**
@@ -1013,6 +1281,7 @@ export class WorkerNode {
             }
         };
         return {
+            get connectionStatus() { return relay.connectionStatus; },
             send: (envelope) => relay.send(envelope),
             ...(relay.acknowledgeDelivery ? { acknowledgeDelivery: (did, id) => relay.acknowledgeDelivery(did, id) } : {}),
             receive,
@@ -1103,30 +1372,8 @@ export class WorkerNode {
             invite.agentDid !== this.agentCard.payload.agentDid ||
             invite.relayUrl !== this.agentCard.payload.relayEndpoint)
             throw new Error('INVITE_WORKER_MISMATCH');
+        this.revocation.assertNotRevoked('invite', digest(invite));
         this.revocation.assertNotRevoked('invite', token);
-        const targetId = this.inviteDigest(token);
-        if (targetId)
-            this.revocation.assertNotRevoked('invite', targetId);
-    }
-    /**
-     * Digest of an invite the worker already holds. Parsing does not dial the relay.
-     * A loopback invite is hashed even when this worker did not opt into dialing it,
-     * so a digest revocation still matches. An unparseable token is not a revocation.
-     */
-    inviteDigest(token) {
-        try {
-            return inviteRevocationId(token, { allowPrivateRelay: this.options.allowPrivateRelay });
-        }
-        catch (error) {
-            if (!(error instanceof Error) || error.message !== 'SSRF_BLOCKED_RELAY_URL')
-                return undefined;
-            try {
-                return inviteRevocationId(token, { allowPrivateRelay: true });
-            }
-            catch {
-                return undefined;
-            }
-        }
     }
     /**
      * Before ACCEPT, every verified capability chain is checked against revocation
@@ -1309,7 +1556,7 @@ function rejectionBody(error) {
 }
 function safeError(e) {
     const s = String(e);
-    for (const code of ['CLAIM_LOST', 'DAILY_LIMIT_REACHED', 'DAILY_TASK_REPLAY', 'DAILY_LIMIT_CLOCK_ROLLBACK', 'DAILY_LIMIT_BUSY', 'DAILY_LIMIT_INVALID', 'UNENCRYPTED_ENVELOPE_REJECTED', 'INVITE_REQUIRED', 'INVITE_EXPIRED', 'INVITE_WORKER_MISMATCH', 'TASK_SCOPE_REJECTED'])
+    for (const code of ['INCOMPATIBLE_TIMEOUTS', 'CLAIM_LOST', 'DAILY_LIMIT_REACHED', 'DAILY_TASK_REPLAY', 'DAILY_LIMIT_CLOCK_ROLLBACK', 'DAILY_LIMIT_BUSY', 'DAILY_LIMIT_INVALID', 'UNENCRYPTED_ENVELOPE_REJECTED', 'INVITE_REQUIRED', 'INVITE_EXPIRED', 'INVITE_WORKER_MISMATCH', 'TASK_SCOPE_REJECTED'])
         if (s === 'Error: ' + code || s.startsWith('Error: ' + code + ':'))
             return code;
     if (s.includes('TOKEN_REVOKED'))
@@ -1336,6 +1583,24 @@ async function abortable(promise, signal) {
         signal.removeEventListener('abort', listener);
     }
 }
+/** Completion failure preserves local verification without claiming a sealed checkpoint. */
+export class IncompleteSettlementError extends Error {
+    incompleteReceipt;
+    code;
+    detail;
+    recovery;
+    constructor(incompleteReceipt, cause) {
+        super(incompleteReceipt.completionError, { cause });
+        this.incompleteReceipt = incompleteReceipt;
+        this.name = 'IncompleteSettlementError';
+        if (cause instanceof Error && 'code' in cause && typeof cause.code === 'string')
+            this.code = cause.code;
+        if (cause instanceof PeerRejectedError) {
+            this.detail = cause.detail;
+            this.recovery = cause.recovery;
+        }
+    }
+}
 /**
  * Queue a signed REVOKE envelope on a worker inbox.
  * The payload is a SignedRevocationNotice. Encryption is on unless encrypt is false,
@@ -1378,6 +1643,7 @@ export class RequesterClient {
     approvalProvider;
     constructor(options) {
         this.options = options;
+        validateSessionTimeouts(options);
         this.approvalProvider =
             options.approvalProvider ?? new InteractiveCliApprovalProvider(options.owner);
     }
@@ -1386,7 +1652,7 @@ export class RequesterClient {
      * `to` is a worker DID or an acp-invite token. The notice is signed by this client.
      */
     async sendRevocation(options) {
-        const invite = options.to.startsWith('acp')
+        const invite = isInviteTarget(options.to)
             ? parseAndVerifyInviteToken(options.to, Date.now(), {
                 allowPrivateRelay: this.options.allowPrivateRelay,
             })
@@ -1413,8 +1679,12 @@ export class RequesterClient {
         });
     }
     async delegate(options, hooks) {
+        const timeoutOptions = resolveSessionTimeouts(this.options, options);
+        validateSessionTimeouts(timeoutOptions);
+        if (timeoutOptions.executionTimeoutMs !== undefined && timeoutOptions.executionTimeoutMs < 1000)
+            throw new Error('INVALID_TIMEOUT: executionTimeoutMs must be at least 1000 (whole-second contract budget)');
         const onProgress = hooks?.onProgress ?? options.onProgress;
-        const invite = options.to.startsWith('acp')
+        const invite = isInviteTarget(options.to)
             ? parseAndVerifyInviteToken(options.to, Date.now(), {
                 allowPrivateRelay: this.options.allowPrivateRelay,
             })
@@ -1431,6 +1701,7 @@ export class RequesterClient {
         const relay = transport(relayOption, this.options.owner, {
             allowPrivateRelay: this.options.allowPrivateRelay,
             lookup: this.options.lookup,
+            requestTimeoutMs: timeoutOptions.connectTimeoutMs,
         }), owner = this.options.owner, inbox = typeof relayOption === 'string'
             ? recipientInbox(this, relay, owner.did, relayOption.replace(/\/$/, ''))
             : recipientInbox(relayOption, relay, owner.did);
@@ -1449,6 +1720,9 @@ export class RequesterClient {
         const manifest = options.manifest ??
             buildTaskManifest({
                 ...options,
+                taskTimeoutMs: timeoutOptions.taskTimeoutMs ?? timeoutOptions.timeoutMs,
+                budget: { ...options.budget, ...(timeoutOptions.executionTimeoutMs !== undefined
+                        ? { maxWallClockSeconds: options.budget?.maxWallClockSeconds ?? Math.floor(timeoutOptions.executionTimeoutMs / 1000) } : {}) },
                 ownerDid: owner.did,
                 workerDid: peer,
                 agentDid: invite?.agentDid ?? card?.payload.agentDid ?? peer,
@@ -1464,6 +1738,12 @@ export class RequesterClient {
                     manifest.budget[field] = Math.min(manifest.budget[field], limit);
             }
         }
+        if (options.manifest && timeoutOptions.executionTimeoutMs !== undefined &&
+            manifest.budget.maxWallClockSeconds * 1000 > timeoutOptions.executionTimeoutMs)
+            throw new Error('INCOMPATIBLE_TIMEOUTS: manifest budget exceeds executionTimeoutMs');
+        if (options.budget?.maxWallClockSeconds !== undefined && timeoutOptions.executionTimeoutMs !== undefined &&
+            options.budget.maxWallClockSeconds * 1000 > timeoutOptions.executionTimeoutMs)
+            throw new Error('INCOMPATIBLE_TIMEOUTS: requested budget exceeds executionTimeoutMs');
         validateManifest(manifest);
         if (manifest.requester.ownerDid !== owner.did ||
             manifest.worker?.ownerDid !== peer ||
@@ -1482,8 +1762,9 @@ export class RequesterClient {
         const auditPath = options.auditPath ?? this.options.auditPath;
         freshAudit(auditPath);
         const bridge = new AbortController();
-        const signal = sessionSignal(Math.min(this.options.timeoutMs ?? 120000, Date.parse(manifest.deadline) - Date.now()), bridge.signal);
         const mailbox = inbox.attach(manifest.taskId);
+        const timeouts = new SessionTimeouts(timeoutOptions, manifest.deadline, bridge.signal);
+        const signal = timeouts.signal;
         const wire = new SessionWire(mailboxRelay(relay, mailbox), owner, peer, manifest.taskId, [owner.did, peer], signal, auditPath, this.options.allowUnencryptedEnvelopes === true);
         if (onProgress) {
             wire.onProgress = async (progress, envelope) => {
@@ -1497,6 +1778,7 @@ export class RequesterClient {
                 });
             };
         }
+        let verifiedReceipt;
         let gateway;
         let deferredCancel = false;
         let cancelStarted = false;
@@ -1549,6 +1831,7 @@ export class RequesterClient {
                 proposal: signPayload(manifest, owner),
                 input: options.input,
                 capabilityChains,
+                peerIdleTimeoutMs: timeoutOptions.transportIdleTimeoutMs ?? 90_000,
                 ...(invite ? { inviteToken: options.to } : {}),
             });
             const accept = (await wire.receiveEvent('ACCEPT')).payload.payload;
@@ -1561,8 +1844,13 @@ export class RequesterClient {
             gateway.machine.apply((await wire.receiveEvent('START')).payload.payload);
             if (options.signal?.aborted || deferredCancel)
                 startCancel();
+            timeouts.executing(timeoutOptions.executionTimeoutMs ?? manifest.budget.maxWallClockSeconds * 1000);
+            wire.onActivity = () => timeouts.activity();
             const envelope = await wire.receiveEvent('DELIVER'), data = envelope.payload.payload;
+            wire.onActivity = undefined;
+            timeouts.wait();
             gateway.machine.apply(data.transition);
+            hooks?.onDelivered?.();
             const approval = () => this.approvalProvider.approve({
                 taskId: manifest.taskId,
                 gate: 'final_verification',
@@ -1570,11 +1858,21 @@ export class RequesterClient {
                 details: { manifest, deliverableDigest: data.artifact.payload.digest },
                 signal,
             });
-            const { result, verification, settlement } = await gateway.verifyAndSettle(wire.sealed(envelope), this.options.verificationEngine ?? new VerificationEngine(), approval, { allowUnencryptedEnvelopes: this.options.allowUnencryptedEnvelopes === true });
+            const { result, verification, settlement } = await abortable(gateway.verifyAndSettle(wire.sealed(envelope), this.options.verificationEngine ?? new VerificationEngine(), approval, { allowUnencryptedEnvelopes: this.options.allowUnencryptedEnvelopes === true }), signal);
             if (!result.accepted || !settlement) {
                 await wire.sendEvent('VERIFY_REJECT', verification);
                 throw new Error('VERIFICATION_REJECTED: ' + result.reason);
             }
+            verifiedReceipt = {
+                workerDid: manifest.worker.agentDid,
+                taskId: manifest.taskId,
+                outputDigest: digest(data.artifact.payload.data),
+                deliverable: data.artifact.payload.data,
+                accepted: true,
+                checkpointComplete: false,
+                delivery: wire.sealed(envelope),
+                verification: result,
+            };
             await wire.sendEvent('VERIFY_ACCEPT', verification);
             await wire.sendEvent('SETTLED', settlement);
             return {
@@ -1586,23 +1884,69 @@ export class RequesterClient {
             };
         }
         catch (e) {
-            if (cancelStarted) {
-                try {
-                    await wire.cancelSession();
-                    const bundle = await wire.finishRequester();
-                    throw Object.assign(new Error('CANCELLED'), { bundle });
+            try {
+                if (e instanceof PeerRejectedError && e.recovery) {
+                    if (e.recovery.proposalDigest !== digest({ manifest, input: options.input }))
+                        throw new Error('INVALID_RECOVERY_OUTCOME');
+                    const cached = e.recovery.result;
+                    if (cached) {
+                        const proposed = cached.bundle?.entries?.find((entry) => entry.body.eventType === 'PROPOSE')
+                            ?.body.payload;
+                        const accepted = cached.bundle?.entries?.find((entry) => entry.body.eventType === 'ACCEPT')
+                            ?.body.payload;
+                        const delivered = cached.bundle?.entries?.find((entry) => entry.body.eventType === 'DELIVER')
+                            ?.body.payload;
+                        if (cached.taskId !== manifest.taskId || !['SETTLED', 'CANCELLED'].includes(cached.state) ||
+                            !verifyAudit(cached.bundle, { taskId: manifest.taskId, actors: [owner.did, peer] }).valid ||
+                            !proposed || digest({ manifest: proposed.proposal.payload, input: proposed.input }) !== e.recovery.proposalDigest ||
+                            !accepted || !verifyContract(accepted.contract) || digest(accepted.contract.manifest) !== digest(manifest) ||
+                            (cached.state === 'CANCELLED' && (e.code !== 'TASK_CANCELLED' || cached.deliverable !== null ||
+                                cached.bundle.entries.at(-1)?.body.eventType !== 'CANCEL')) ||
+                            (cached.state === 'SETTLED' && (!delivered ||
+                                e.code !== 'TASK_SETTLED' ||
+                                digest(delivered.artifact.payload.data) !== digest(cached.deliverable) ||
+                                cached.bundle.entries.at(-1)?.body.eventType !== 'SETTLED')))
+                            throw new Error('INVALID_RECOVERY_OUTCOME');
+                        if (cached.state === 'SETTLED')
+                            hooks?.onDelivered?.();
+                        return cached;
+                    }
                 }
-                catch (inner) {
-                    if (inner instanceof Error && inner.message === 'CANCELLED')
+                if (verifiedReceipt)
+                    throw e;
+                // A closed recipient inbox is terminal for every attached task. Do not wait
+                // for another relay send (or cancellation handshake) on the failed connection.
+                if (e instanceof Error && 'code' in e && ['RELAY_TERMINAL', 'RELAY_ENVELOPE_EXPIRED'].includes(String(e.code)))
+                    throw e;
+                if (cancelStarted) {
+                    try {
+                        await wire.cancelSession();
+                        const bundle = await wire.finishRequester();
+                        throw Object.assign(new Error('CANCELLED'), { bundle });
+                    }
+                    catch (inner) {
+                        if (inner instanceof Error && inner.message === 'CANCELLED')
+                            throw inner;
+                        await wire.rawSend('ERROR', { code: safeError(inner) }).catch(() => { });
                         throw inner;
-                    await wire.rawSend('ERROR', { code: safeError(inner) }).catch(() => { });
-                    throw inner;
+                    }
                 }
+                await wire.rawSend('ERROR', { code: safeError(e) }).catch(() => { });
+                throw e;
+            }
+            catch (error) {
+                if (!verifiedReceipt)
+                    throw error;
+                throw new IncompleteSettlementError({
+                    ...verifiedReceipt,
+                    entries: wire.entries.slice(),
+                    completionError: error instanceof Error ? error.message : String(error),
+                }, error);
             }
-            await wire.rawSend('ERROR', { code: safeError(e) }).catch(() => { });
-            throw e;
         }
         finally {
+            timeouts.close();
+            wire.close();
             options.signal?.removeEventListener('abort', onUserAbort);
             inbox.detach(manifest.taskId);
             gateway?.close();
@@ -1613,6 +1957,10 @@ export class RequesterClient {
             throw new Error('WORKERS_REQUIRED');
         if (options.mode !== 'race' && options.mode !== 'quorum')
             throw new Error('INVALID_DELEGATION_MODE');
+        const completionTimeoutMs = options.completionTimeoutMs ?? 45_000;
+        assertPositive('COMPLETION_TIMEOUT', completionTimeoutMs);
+        if (completionTimeoutMs > 2_147_483_647)
+            throw new Error('INVALID_COMPLETION_TIMEOUT');
         const count = options.workers.length;
         const quorumSize = options.quorumSize ?? Math.floor(count / 2) + 1;
         if (options.mode === 'quorum' &&
@@ -1633,13 +1981,23 @@ export class RequesterClient {
         }
         const controllers = options.workers.map(() => new AbortController());
         const finished = options.workers.map(() => false);
+        const delivered = options.workers.map(() => false);
+        const completionTimers = [];
         const receipts = [];
+        const incompleteReceipts = [];
         let failures = 0;
         let winnerDigest;
         const abortUnfinished = (reason) => {
             controllers.forEach((controller, index) => {
-                if (!finished[index])
+                if (finished[index])
+                    return;
+                if (!delivered[index])
                     controller.abort(reason);
+                else if (!completionTimers[index]) {
+                    // DELIVER has left execution: preserve verification and bilateral checkpointing.
+                    completionTimers[index] = setTimeout(() => controller.abort(new Error('COMPLETION_TIMEOUT')), completionTimeoutMs);
+                    completionTimers[index].unref();
+                }
             });
         };
         const jobs = resolved.map(async (worker, index) => {
@@ -1654,6 +2012,13 @@ export class RequesterClient {
                     description: options.description,
                     input: options.input,
                     outputSchema: options.outputSchema,
+                    executionTimeoutMs: options.executionTimeoutMs,
+                    timeoutMs: options.timeoutMs,
+                    taskTimeoutMs: options.taskTimeoutMs,
+                    waitTimeoutMs: options.waitTimeoutMs,
+                    connectTimeoutMs: options.connectTimeoutMs,
+                    transportIdleTimeoutMs: options.transportIdleTimeoutMs,
+                    heartbeatIntervalMs: options.heartbeatIntervalMs,
                     budget: options.budget,
                     capabilities: options.capabilities,
                     minimumIsolationLevel: options.minimumIsolationLevel,
@@ -1662,7 +2027,7 @@ export class RequesterClient {
                     auditPath: options.auditPath
                         ? options.auditPath.replace(/(\.jsonl)?$/, '.' + index + '.jsonl')
                         : undefined,
-                });
+                }, { onDelivered: () => { delivered[index] = true; } });
                 finished[index] = true;
                 // SETTLED always carries a verified deliverable, including JSON null.
                 if (result.state !== 'SETTLED')
@@ -1689,12 +2054,17 @@ export class RequesterClient {
                 return { index, result, outputDigest, workerDid };
             }
             catch (error) {
+                if (error instanceof IncompleteSettlementError)
+                    incompleteReceipts.push(error.incompleteReceipt);
                 finished[index] = true;
                 failures += 1;
                 if (options.mode === 'quorum' && !winnerDigest && failures > count - quorumSize)
                     abortUnfinished('QUORUM_UNREACHABLE');
                 throw error;
             }
+            finally {
+                clearTimeout(completionTimers[index]);
+            }
         });
         if (options.mode === 'race') {
             let winner;
@@ -1702,7 +2072,7 @@ export class RequesterClient {
                 winner = await Promise.any(jobs);
             }
             catch {
-                throw new Error('RACE_FAILED');
+                throw Object.assign(new Error('RACE_FAILED'), { receipts, incompleteReceipts });
             }
             abortUnfinished('RACE_LOST');
             await Promise.allSettled(jobs);
@@ -1721,14 +2091,15 @@ export class RequesterClient {
                     },
                 ],
                 receipts,
+                incompleteReceipts,
                 cancelled: resolved
-                    .filter((_, index) => index !== winner.index && controllers[index].signal.aborted)
+                    .filter((_, index) => index !== winner.index && controllers[index].signal.aborted && !delivered[index])
                     .map((worker) => worker.workerDid),
             };
         }
         await Promise.allSettled(jobs);
         if (!winnerDigest)
-            throw Object.assign(new Error('QUORUM_NOT_REACHED'), { receipts });
+            throw Object.assign(new Error('QUORUM_NOT_REACHED'), { receipts, incompleteReceipts });
         const seenWinners = new Set();
         const winners = receipts.filter((receipt) => {
             if (receipt.outputDigest !== winnerDigest || seenWinners.has(receipt.workerDid))
@@ -1748,8 +2119,9 @@ export class RequesterClient {
                 outputDigest: receipt.outputDigest,
             })),
             receipts,
+            incompleteReceipts,
             cancelled: resolved
-                .filter((_, index) => controllers[index].signal.aborted)
+                .filter((_, index) => controllers[index].signal.aborted && !delivered[index])
                 .map((worker) => worker.workerDid),
         };
     }
@@ -1835,7 +2207,7 @@ async function canonicalizeDiscoveredWorkers(targets, options) {
     }));
 }
 export function buildTaskManifest(options) {
-    const createdAt = new Date().toISOString(), deadline = new Date(Date.now() + 600000).toISOString();
+    const createdAt = new Date().toISOString(), deadline = new Date(Date.now() + (options.taskTimeoutMs ?? 600000)).toISOString();
     return {
         protocolVersion: '0.1.0',
         taskId: 'task_' + randomUUID().replaceAll('-', ''),